From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtpbg156.qq.com (smtpbg156.qq.com [15.184.82.18]) by sourceware.org (Postfix) with ESMTPS id 258603858D28 for ; Tue, 18 Apr 2023 01:56:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 258603858D28 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=rivai.ai Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=rivai.ai X-QQ-mid: bizesmtp76t1681782998t3ecp9os Received: from rios-cad5.localdomain ( [58.60.1.11]) by bizesmtp.qq.com (ESMTP) with id ; Tue, 18 Apr 2023 09:56:35 +0800 (CST) X-QQ-SSF: 01400000000000F0P000000A0000000 X-QQ-FEAT: vrqOr+ppv0s0Gp935vEVuIxX8KLN04a4ug8txUZij3xan4JsLG/gOjgdtkxvI dCctnvT66uG+uoTBzjsL6wvdOU9CaMfkE1n5ohgpj0+cpwJN3y+9FtyOx87v+1uKO0oMYc2 BPWZBJhWy7zUSf19nc6aCIhMdCbvbirdOmJfS35HLr4Iqas5PyuAVXtO3pLp9uLSUzWwGIX QaSO3P2rGZWvpgTwMzEQfkgkQpPk9KOTveq0U/SZXHYSQB3YuQnttI3NKRtJTMew+YQ5idT MRrkDbTp67hTwfaeeUkvmYm5TVrGkVqUQS1kGdTWijGQ1ocQ/v7Uz88jZi1osODtqJRYNR9 kCj374yvvntwvT3gZVtcnEbxeHLniKg67wCWyuZ X-QQ-GoodBg: 2 X-BIZMAIL-ID: 4238742978527696990 From: juzhe.zhong@rivai.ai To: gcc-patches@gcc.gnu.org Cc: kito.cheng@gmail.com, palmer@dabbelt.com, Ju-Zhe Zhong Subject: [PATCH] RISC-V: Fix PR109535 Date: Tue, 18 Apr 2023 09:56:33 +0800 Message-Id: <20230418015634.35491-1-juzhe.zhong@rivai.ai> X-Mailer: git-send-email 2.36.3 MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-QQ-SENDSIZE: 520 Feedback-ID: bizesmtp:rivai.ai:qybglogicsvr:qybglogicsvr7 X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00,GIT_PATCH_0,KAM_DMARC_STATUS,KAM_LINEPADDING,KAM_NUMSUBJECT,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE,WEIRD_PORT autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Ju-Zhe Zhong PR 109535 gcc/ChangeLog: * config/riscv/riscv-vsetvl.cc (count_regno_occurrences): New funct= ion. (pass_vsetvl::cleanup_insns): replace counting rtx with counting re= gno. gcc/testsuite/ChangeLog: * g++.target/riscv/rvv/base/pr109535.C: New test. --- gcc/config/riscv/riscv-vsetvl.cc | 15 +- .../g++.target/riscv/rvv/base/pr109535.C | 112973 +++++++++++++++ 2 files changed, 112987 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/g++.target/riscv/rvv/base/pr109535.C diff --git a/gcc/config/riscv/riscv-vsetvl.cc b/gcc/config/riscv/riscv-vset= vl.cc index 1b66e3b9eeb..43e2cf08377 100644 --- a/gcc/config/riscv/riscv-vsetvl.cc +++ b/gcc/config/riscv/riscv-vsetvl.cc @@ -1592,6 +1592,19 @@ backward_propagate_worthwhile_p (const basic_block c= fg_bb, return true; } =20 +/* Count the number of REGNO in RINSN. */ +int +count_regno_occurrences (rtx_insn *rinsn, unsigned int regno) +{ + int count =3D 0; + extract_insn (rinsn); + for (int i =3D 0; i < recog_data.n_operands; i++) + if (REG_P (recog_data.operand[i]) + && REGNO (recog_data.operand[i]) =3D=3D regno) + count++; + return count; +} + avl_info::avl_info (const avl_info &other) { m_value =3D other.get_value (); @@ -3924,7 +3937,7 @@ pass_vsetvl::cleanup_insns (void) const if (!has_vl_op (rinsn) || !REG_P (get_vl (rinsn))) continue; rtx avl =3D get_vl (rinsn); - if (count_occurrences (PATTERN (rinsn), avl, 0) =3D=3D 1) + if (count_regno_occurrences (rinsn, REGNO (avl)) =3D=3D 1) { /* Get the list of uses for the new instruction. */ auto attempt =3D crtl->ssa->new_change_attempt (); diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/pr109535.C b/gcc/tests= uite/g++.target/riscv/rvv/base/pr109535.C new file mode 100644 index 00000000000..49eb2e78a5d --- /dev/null +++ b/gcc/testsuite/g++.target/riscv/rvv/base/pr109535.C @@ -0,0 +1,112973 @@ +/* { dg-do compile } */ +/* { dg-options "-march=3Drv64gcv -mabi=3Dlp64d -O3" } */ + +// Target: riscv64-linux-gnu +// Configured with: ../src/configure -v --with-pkgversion=3D'Debian 13-202= 30411-1' --with-bugurl=3Dfile:///usr/share/doc/gcc-13/README.Bugs --enable-= languages=3Dc,ada,c++,go,d,fortran,objc,obj-c++,m2,rust --prefix=3D/usr --w= ith-gcc-major-version-only --program-suffix=3D-13 --program-prefix=3Driscv6= 4-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=3D/usr/l= ibexec --without-included-gettext --enable-threads=3Dposix --libdir=3D/usr/= lib --enable-nls --enable-clocale=3Dgnu --enable-libstdcxx-debug --enable-l= ibstdcxx-time=3Dyes --with-default-libstdcxx-abi=3Dnew --enable-gnu-unique-= object --disable-libitm --disable-libquadmath --disable-libquadmath-support= --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos= -checking=3Drelease --with-target-system-zlib=3Dauto --enable-objc-gc=3Daut= o --enable-multiarch --disable-werror --disable-multilib --with-arch=3Drv64= gc --with-abi=3Dlp64d --enable-checking=3Drelease --build=3Driscv64-linux-g= nu --host=3Driscv64-linux-gnu --target=3Driscv64-linux-gnu --with-build-con= fig=3Dbootstrap-lto-lean --enable-link-serialization=3D2 +// Thread model: posix +// Supported LTO compression algorithms: zlib zstd +// gcc version 13.0.1 20230411 (experimental) [master r13-7137-gb8e32978e3= d] (Debian 13-20230411-1)=20 +//=20 +// during RTL pass: vsetvl +// /home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transfor= m_test.cc: In function 'void hwy::N_RVV::ForeachCountAndMisalign::ope= rator()(T, D) const [with T =3D unsigned char; D =3D hwy::N_RVV::Simd; Test =3D hwy::N_RVV::TestGenerate]': +// /home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transfor= m_test.cc:133:3: internal compiler error: in finalize_new_accesses, at rtl-= ssa/changes.cc:471 +// 133 | } +// | ^ +// 0xf4b18d rtl_ssa::function_info::finalize_new_accesses(rtl_ssa::insn_ch= ange&) +// ../../src/gcc/rtl-ssa/changes.cc:471 +// 0xf4c0a7 rtl_ssa::function_info::change_insns(array_slice) +// ../../src/gcc/rtl-ssa/changes.cc:659 +// 0xb4f1e7 rtl_ssa::function_info::change_insn(rtl_ssa::insn_change&) +// ../../src/gcc/rtl-ssa/changes.cc:717 +// 0xb4f1e7 change_insn +// ../../src/gcc/config/riscv/riscv-vsetvl.cc:1028 +// 0xb4f1e7 pass_vsetvl::cleanup_insns() const +// ../../src/gcc/config/riscv/riscv-vsetvl.cc:3951 +// 0xb59891 pass_vsetvl::lazy_vsetvl() +// ../../src/gcc/config/riscv/riscv-vsetvl.cc:4211 +// 0xb59a7d pass_vsetvl::execute(function*) +// ../../src/gcc/config/riscv/riscv-vsetvl.cc:4241 +// 0xb59a7d pass_vsetvl::execute(function*) +// ../../src/gcc/config/riscv/riscv-vsetvl.cc:4222 +// Please submit a full bug report, with preprocessed source. +// Please include the complete backtrace with any bug report. +// See for instructions. + +// /usr/libexec/gcc/riscv64-linux-gnu/13/cc1plus -quiet -I /home/malat/hig= hway-1.0.4~git20230317.8681eb8 -imultilib . -imultiarch riscv64-linux-gnu -= MD CMakeFiles/transform_test.dir/hwy/contrib/algo/transform_test.cc.d -MF C= MakeFiles/transform_test.dir/hwy/contrib/algo/transform_test.cc.o.d -MT CMa= keFiles/transform_test.dir/hwy/contrib/algo/transform_test.cc.o -D_GNU_SOUR= CE -D HWY_SHARED_DEFINE -D HWY_BROKEN_EMU128=3D0 -D _FORTIFY_SOURCE=3D2 -D = __DATE__=3D"redacted" -D __TIMESTAMP__=3D"redacted" -D __TIME__=3D"redacted= " -D HWY_IS_TEST=3D1 -D GTEST_HAS_PTHREAD=3D1 /home/malat/highway-1.0.4~git= 20230317.8681eb8/hwy/contrib/algo/transform_test.cc -quiet -dumpdir CMakeFi= les/transform_test.dir/hwy/contrib/algo/ -dumpbase transform_test.cc.cc -du= mpbase-ext .cc -march=3Drv64gcv1p0 -mabi=3Dlp64d -misa-spec=3D20191213 -mar= ch=3Drv64imafdc_v1p0_zicsr_zifencei_zve32f_zve32x_zve64d_zve64f_zve64x_zvl1= 28b_zvl32b_zvl64b -g -O2 -Wformat=3D1 -Werror=3Dformat-security -Wdate-time= -Wno-builtin-macro-redefined -Wall -Wextra -Wconversion -Wsign-conversion = -Wvla -Wnon-virtual-dtor -Werror -freport-bug -ffile-prefix-map=3D/home/mal= at/highway-1.0.4~git20230317.8681eb8=3D. -fstack-protector-strong -fPIE -fv= isibility=3Dhidden -fvisibility-inlines-hidden -fmerge-all-constants -fmath= -errno -fno-exceptions -o - -frandom-seed=3D0 -fdump-noaddr + +# 0 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transf= orm_test.cc" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/obj-riscv64-linux-gnu//" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transf= orm_test.cc" +# 16 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" +# 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 +# 33 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 392 "/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 +# 393 "/usr/include/features.h" 2 3 4 +# 489 "/usr/include/features.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 1 3 4 +# 559 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 +# 560 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/long-double.h" 1 3 4 +# 561 "/usr/include/riscv64-linux-gnu/sys/cdefs.h" 2 3 4 +# 490 "/usr/include/features.h" 2 3 4 +# 513 "/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 +# 514 "/usr/include/features.h" 2 3 4 +# 34 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 2 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 214 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 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 __sr= c, + 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) __att= ribute__ ((__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__)) __attrib= ute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attrib= ute__ ((__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__)) __attr= ibute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attr= ibute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attri= bute__ ((__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__)) __attri= bute__ ((__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 __sr= c, + 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__ ((__ac= cess__ (__write_only__, 1, 3))); + + + +# 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; +# 173 "/usr/include/string.h" 2 3 4 + + +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__ ((__nonnul= l__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnul= l__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribu= te__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribu= te__ ((__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__)) __attrib= ute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attrib= ute__ ((__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__)) __attr= ibute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attr= ibute__ ((__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__)) __attrib= ute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attrib= ute__ ((__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__)) __attribu= te__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribu= te__ ((__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 __deli= m, + 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__)) __att= ribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __att= ribute__ ((__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__ ((__w= arn_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/13/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__)) __attribut= e__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribut= e__ ((__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__)) __attribu= te__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribu= te__ ((__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 __lo= c) + 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_object_size (__dest, 0)); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) void +__attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) noexcept (tr= ue) +{ + (void) __builtin___memset_chk (__dest, '\0', __len, + __builtin_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) __attri= bute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +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 __s= rc) + 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 int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull_= _ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__non= null__ (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))); +# 535 "/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_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_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_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) n= oexcept (true) +{ + return __builtin___memset_chk (__dest, __ch, __len, + __builtin_object_size (__dest, 0)); +} + + + + +void __explicit_bzero_chk (void *__dest, size_t __len, size_t __destlen) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__acce= ss__ (__write_only__, 1, 2))); + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) void +__attribute__ ((__leaf__)) explicit_bzero (void *__dest, size_t __len) noe= xcept (true) +{ + __explicit_bzero_chk (__dest, __len, __builtin_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_object_size (__d= est, 2 > 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_object_size (__d= est, 2 > 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_object_size (__dest, 2 > 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_object_size (__dest, 2 > 1)); +} +# 127 "/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_object_size (__d= est, 2 > 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_object_size (__dest, 2 > 1)); +} +# 536 "/usr/include/string.h" 2 3 4 + + + +} +# 17 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" 2 + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.h= " 1 +# 21 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 145 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 425 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long lon= g)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long d= ouble)))); +# 436 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" 2 + +# 1 "/usr/include/c++/13/memory" 1 3 +# 47 "/usr/include/c++/13/memory" 3 +=20=20=20=20=20=20=20 +# 48 "/usr/include/c++/13/memory" 3 +# 63 "/usr/include/c++/13/memory" 3 +# 1 "/usr/include/c++/13/bits/memoryfwd.h" 1 3 +# 46 "/usr/include/c++/13/bits/memoryfwd.h" 3 +=20=20=20=20=20=20=20 +# 47 "/usr/include/c++/13/bits/memoryfwd.h" 3 + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 1 3 +# 306 "/usr/include/riscv64-linux-gnu/c++/13/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__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/os_defines.h" 1 3 +# 680 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 2 3 + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/cpu_defines.h" 1 3 +# 683 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 2 3 +# 882 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 3 +# 1 "/usr/include/c++/13/pstl/pstl_config.h" 1 3 +# 883 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++config.h" 2 3 +# 49 "/usr/include/c++/13/bits/memoryfwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/13/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + + + template + struct uses_allocator; + + template + struct allocator_traits; + + + + + +} +# 64 "/usr/include/c++/13/memory" 2 3 + +# 1 "/usr/include/c++/13/bits/allocator.h" 1 3 +# 46 "/usr/include/c++/13/bits/allocator.h" 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++allocator.h" 1 3 +# 33 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++allocator.h" 3 +# 1 "/usr/include/c++/13/bits/new_allocator.h" 1 3 +# 34 "/usr/include/c++/13/bits/new_allocator.h" 3 +# 1 "/usr/include/c++/13/new" 1 3 +# 38 "/usr/include/c++/13/new" 3 +=20=20=20=20=20=20=20 +# 39 "/usr/include/c++/13/new" 3 + + +# 1 "/usr/include/c++/13/bits/exception.h" 1 3 +# 34 "/usr/include/c++/13/bits/exception.h" 3 +=20=20=20=20=20=20=20 +# 35 "/usr/include/c++/13/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/include/c++/13/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) =3D default; + exception& operator=3D(const exception&) =3D default; + exception(exception&&) =3D default; + exception& operator=3D(exception&&) =3D default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/include/c++/13/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) =3D default; + bad_alloc& operator=3D(const bad_alloc&) =3D 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() =3D default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 126 "/usr/include/c++/13/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +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&) n= oexcept + __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), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const = std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __ma= lloc__)); +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), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, cons= t std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __ma= lloc__)); +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__)); + + + + +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexce= pt +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noex= cept +{ 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 + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) =3D delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) =3D delete; + + void launder(void*) =3D delete; + void launder(const void*) =3D delete; + void launder(volatile void*) =3D delete; + void launder(const volatile void*) =3D delete; + + + + + inline constexpr size_t hardware_destructive_interference_size =3D 32; + inline constexpr size_t hardware_constructive_interference_size =3D 32; + +} +# 236 "/usr/include/c++/13/new" 3 +#pragma GCC visibility pop +# 35 "/usr/include/c++/13/bits/new_allocator.h" 2 3 +# 1 "/usr/include/c++/13/bits/functexcept.h" 1 3 +# 40 "/usr/include/c++/13/bits/functexcept.h" 3 +# 1 "/usr/include/c++/13/bits/exception_defines.h" 1 3 +# 41 "/usr/include/c++/13/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__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 140 "/usr/include/c++/13/bits/functexcept.h" 3 + +} +# 36 "/usr/include/c++/13/bits/new_allocator.h" 2 3 +# 1 "/usr/include/c++/13/bits/move.h" 1 3 +# 38 "/usr/include/c++/13/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } + + + + +} + +# 1 "/usr/include/c++/13/type_traits" 1 3 +# 32 "/usr/include/c++/13/type_traits" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/include/c++/13/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value =3D __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + + + + + constexpr value_type operator()() const noexcept { return value; } + + }; + + + + + + + + using true_type =3D integral_constant; + + + using false_type =3D integral_constant; + + + + template + using __bool_constant =3D integral_constant; + + + + + + + template + using bool_constant =3D integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t =3D typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type =3D _Tp; + }; + + template<> + struct __conditional + { + template + using type =3D _Up; + }; + + + template + using __conditional_t + =3D typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type =3D _Type; }; + + template + using __type_identity_t =3D typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t =3D _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 =3D __or_<_Bn...>::value; + template + inline constexpr bool __and_v =3D __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type =3D _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2= , _Bn...> + { using type =3D typename __disjunction_impl::typ= e; }; + + template + struct __conjunction_impl + { using type =3D _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2,= _Bn...> + { using type =3D typename __conjunction_impl::typ= e; }; + } + + + + + 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 =3D conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v =3D disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v =3D 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 =3D 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 { }; +# 440 "/usr/include/c++/13/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 { }; +# 500 "/usr/include/c++/13/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + 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_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + 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 false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + 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 __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + 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 __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of =3D __or_...>; + + + __extension__ + template + using __is_signed_integer =3D __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 733 "/usr/include/c++/13/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer =3D __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 753 "/usr/include/c++/13/type_traits" 3 + >; + + + template + using __is_standard_integer + =3D __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t =3D void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : 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 is_trivially_copyable + : 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 is_standard_layout + : 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 +=20=20=20 + is_pod + : 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 + [[__deprecated__]] + is_literal_type + : 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 is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + 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 + { }; +# 936 "/usr/include/c++/13/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 + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool =3D __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 + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool =3D __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 + =3D __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 + struct __add_lvalue_reference_helper + { using type =3D _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type =3D _Tp&; }; + + template + using __add_lval_ref_t =3D typename __add_lvalue_reference_helper<_Tp>= ::type; + + + + 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 + struct __add_rvalue_reference_helper + { using type =3D _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type =3D _Tp&&; }; + + template + using __add_rval_ref_t =3D typename __add_rvalue_reference_helper<_Tp>= ::type; + + + + 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 + =3D __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 =3D __bool_constant<__is_assignable(_Tp, _U= p)>; + + + + 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 + =3D __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 + =3D __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"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* =3D 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + 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 + =3D __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 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 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 { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + 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 integral_constant + + + + { }; +# 1409 "/usr/include/c++/13/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/include/c++/13/type_traits" 3 + template + using __is_array_convertible + =3D is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/include/c++/13/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type =3D __remove_cv(_Tp); }; +# 1563 "/usr/include/c++/13/type_traits" 3 + template + struct add_const + { using type =3D _Tp const; }; + + + template + struct add_volatile + { using type =3D _Tp volatile; }; + + + template + struct add_cv + { using type =3D _Tp const volatile; }; + + + + + + + template + using remove_const_t =3D typename remove_const<_Tp>::type; + + + template + using remove_volatile_t =3D typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t =3D typename remove_cv<_Tp>::type; + + + template + using add_const_t =3D typename add_const<_Tp>::type; + + + template + using add_volatile_t =3D typename add_volatile<_Tp>::type; + + + template + using add_cv_t =3D typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type =3D __remove_reference(_Tp); }; +# 1628 "/usr/include/c++/13/type_traits" 3 + template + struct add_lvalue_reference + { using type =3D __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type =3D __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t =3D typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t =3D typename add_lvalue_reference<_Tp>::t= ype; + + + template + using add_rvalue_reference_t =3D typename add_rvalue_reference<_Tp>::t= ype; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::value, + bool _IsVol =3D is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + template + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { typedef unsigned __int128 __type; }; +# 1741 "/usr/include/c++/13/type_traits" 3 + template::value, + bool _IsEnum =3D is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + =3D typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + =3D 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 =3D sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type =3D _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 =3D _List; + + using __unsigned_type =3D typename __select::__= type; + + public: + using __type + =3D typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + =3D typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/include/c++/13/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + =3D typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + =3D typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; + + + __extension__ + template<> + struct __make_signed + { typedef __int128 __type; }; +# 1901 "/usr/include/c++/13/type_traits" 3 + template::value, + bool _IsEnum =3D is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + =3D typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + =3D typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_ty= pe; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __t= ype; + }; + + + + + + template<> + struct __make_signed + { + using __type + =3D typename __make_signed_selector::__type; + }; +# 1947 "/usr/include/c++/13/type_traits" 3 + template<> + struct __make_signed + { + using __type + =3D typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + =3D typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t =3D typename make_signed<_Tp>::type; + + + template + using make_unsigned_t =3D typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t =3D typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t =3D typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type =3D _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type =3D _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type =3D _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type =3D _Tp*; }; + + + + template + using remove_pointer_t =3D typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t =3D typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/include/c++/13/type_traits" 3 + template::__type)> + struct +=20=20=20 + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment =3D 0; + static const size_t _S_size =3D 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment =3D + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size =3D + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/include/c++/13/type_traits" 3 + template + struct +=20=20=20 + aligned_union + { + private: + static_assert(sizeof...(_Types) !=3D 0, "At least one type is requir= ed"); + + using __strictest =3D __strictest_alignment<_Types...>; + static const size_t _S_len =3D _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value =3D __strictest::_S_alignment; + + typedef typename aligned_storage<_S_len, alignment_value>::type type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type =3D _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type =3D _Up*; }; + + + + + template + struct decay + { using type =3D typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type =3D typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type =3D typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t =3D typename decay<_Tp>::type; + + template + using __decay_and_strip =3D __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require =3D __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + =3D typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/include/c++/13/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + =3D decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/include/c++/13/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 =3D __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type =3D common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type =3D 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::value> + struct __underlying_type_impl + { + using type =3D __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 =3D 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 =3D _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 + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + 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 + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + 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 + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + 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 + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type =3D _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type =3D _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type 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 + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + 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 + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' in= stead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t =3D typename aligned_storage<_Len, _Align>::ty= pe; + + template + using aligned_union_t =3D typename aligned_union<_Len, _Types...>::typ= e; +#pragma GCC diagnostic pop + + + template + using decay_t =3D typename decay<_Tp>::type; + + + template + using enable_if_t =3D typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t =3D typename conditional<_Cond, _Iftrue, _Iffalse>= ::type; + + + template + using common_type_t =3D typename common_type<_Tp...>::type; + + + template + using underlying_type_t =3D typename underlying_type<_Tp>::type; + + + template + using result_of_t =3D typename result_of<_Tp>::type; + + + + + + template using void_t =3D void; +# 2659 "/usr/include/c++/13/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type =3D _Default; + using __is_detected =3D false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type =3D _Op<_Args...>; + using __is_detected =3D true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or =3D __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + =3D typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/include/c++/13/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 +=20=20=20 + 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 +=20=20=20 + 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 + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + 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 =3D + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v =3D + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())= ), + typename + =3D 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 + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + 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 =3D + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v =3D + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/include/c++/13/type_traits" 3 + template::value, typename =3D void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv =3D false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv =3D 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 =3D typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename =3D decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle =3D __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type =3D decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv =3D 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 =3D 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 =3D 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_ + =3D __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() =3D delete; + __nonesuch(__nonesuch const&) =3D delete; + void operator=3D(__nonesuch const&) =3D delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Funct= or>{}), + "_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 =3D typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::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"); + }; + + + 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 + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __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"); + }; + + + + + + template + using __is_nt_invocable_impl + =3D typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _R= et>, + __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"); + }; +# 3155 "/usr/include/c++/13/type_traits" 3 +template + inline constexpr bool is_void_v =3D is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v =3D is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v =3D is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v =3D is_floating_point<_Tp>::va= lue; + +template + inline constexpr bool is_array_v =3D false; +template + inline constexpr bool is_array_v<_Tp[]> =3D true; +template + inline constexpr bool is_array_v<_Tp[_Num]> =3D true; + +template + inline constexpr bool is_pointer_v =3D is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v =3D false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> =3D true; +template + inline constexpr bool is_rvalue_reference_v =3D false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> =3D true; +template + inline constexpr bool is_member_object_pointer_v =3D + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v =3D + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v =3D __is_enum(_Tp); +template + inline constexpr bool is_union_v =3D __is_union(_Tp); +template + inline constexpr bool is_class_v =3D __is_class(_Tp); +template + inline constexpr bool is_function_v =3D is_function<_Tp>::value; +template + inline constexpr bool is_reference_v =3D false; +template + inline constexpr bool is_reference_v<_Tp&> =3D true; +template + inline constexpr bool is_reference_v<_Tp&&> =3D true; +template + inline constexpr bool is_arithmetic_v =3D is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v =3D is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v =3D is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v =3D is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v =3D is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v =3D is_member_pointer<_Tp>::va= lue; +template + inline constexpr bool is_const_v =3D false; +template + inline constexpr bool is_const_v =3D true; +template + inline constexpr bool is_volatile_v =3D false; +template + inline constexpr bool is_volatile_v =3D true; + +template + inline constexpr bool is_trivial_v =3D __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v =3D __is_trivially_copyabl= e(_Tp); +template + inline constexpr bool is_standard_layout_v =3D __is_standard_layout(_Tp); +template +=20 + inline constexpr bool is_pod_v =3D __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v =3D __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v =3D __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v =3D __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v =3D __is_abstract(_Tp); +template + inline constexpr bool is_final_v =3D __is_final(_Tp); + +template + inline constexpr bool is_signed_v =3D is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v =3D is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v =3D __is_constructible(_Tp, _Ar= gs...); +template + inline constexpr bool is_default_constructible_v =3D __is_constructible(= _Tp); +template + inline constexpr bool is_copy_constructible_v + =3D __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + =3D __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v =3D __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + =3D __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t= ); +template + inline constexpr bool is_move_assignable_v + =3D __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v =3D is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + =3D __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + =3D __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + =3D __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + =3D __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + =3D __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + =3D __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + =3D __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v =3D + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + =3D __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + =3D __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + =3D __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + =3D __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + =3D __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + =3D __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + =3D __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_T= p>); + +template + inline constexpr bool is_nothrow_destructible_v =3D + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + =3D __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v =3D alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v =3D 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> =3D 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> =3D 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v =3D 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> =3D _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> =3D extent_v<_Tp, _Id= x - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> =3D 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> =3D extent_v<_Tp, _Idx - 1= >; + + +template + inline constexpr bool is_same_v =3D __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v =3D __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v =3D __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v =3D is_invocable<_Fn, _Args...>::va= lue; +template + inline constexpr bool is_nothrow_invocable_v + =3D is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + =3D is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + =3D 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 + =3D 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 =3D __is_aggregate(remove_cv_t<_T= p>); +# 3828 "/usr/include/c++/13/type_traits" 3 + +} +# 58 "/usr/include/c++/13/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + 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); + } + + + + + + + template + [[__nodiscard__]] + 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 { }; +# 121 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 142 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) =3D delete; + + + template +=20=20=20 + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val =3D std::move(__obj); + __obj =3D std::forward<_Up>(__new_val); + return __old_val; + } +# 186 "/usr/include/c++/13/bits/move.h" 3 + template +=20=20=20 + 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_as= signable<_Tp>>::value) + + { + + + + + _Tp __tmp =3D std::move(__a); + __a =3D std::move(__b); + __b =3D std::move(__tmp); + } + + + + + template +=20=20=20 + 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 =3D 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 37 "/usr/include/c++/13/bits/new_allocator.h" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 62 "/usr/include/c++/13/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__)) +=20=20=20=20=20 + __new_allocator() noexcept { } + + __attribute__((__always_inline__)) +=20=20=20=20=20 + __new_allocator(const __new_allocator&) noexcept { } + + template + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator<_Tp1>&) noexcept { } + + + ~__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); } +# 121 "/usr/include/c++/13/bits/new_allocator.h" 3 + [[__nodiscard__]] _Tp* + allocate(size_type __n, const void* =3D static_cast(0)) + { + + + + static_assert(sizeof(_Tp) !=3D 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 =3D std::align_val_t(alignof(_Tp)); + return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), + __al)); + } + + return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); + } + + + void + deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) + { + + + + + + + + if (alignof(_Tp) > 16) + { + ::operator delete((__p), (__n) * sizeof(_Tp), + std::align_val_t(alignof(_Tp))); + return; + } + + ::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(std::is_nothrow_constructible<_Up, _Args...>::value) + { ::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(); } +# 209 "/usr/include/c++/13/bits/new_allocator.h" 3 + template + friend __attribute__((__always_inline__)) bool + operator=3D=3D(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return true; } + + + template + friend __attribute__((__always_inline__)) bool + operator!=3D(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++/13/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 46 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++allocator.h" 3 + template + using __allocator_base =3D __new_allocator<_Tp>; +} +# 47 "/usr/include/c++/13/bits/allocator.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/13/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 =3D true_type; + + using is_always_equal + + =3D true_type; +# 117 "/usr/include/c++/13/bits/allocator.h" 3 + }; +# 129 "/usr/include/c++/13/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 =3D true_type; + + using is_always_equal + + =3D true_type; + + + + + __attribute__((__always_inline__)) +=20=20=20=20=20 + allocator() noexcept { } + + __attribute__((__always_inline__)) +=20=20=20=20=20 + allocator(const allocator& __a) noexcept + : __allocator_base<_Tp>(__a) { } + + + + allocator& operator=3D(const allocator&) =3D default; + + + template + __attribute__((__always_inline__)) + + allocator(const allocator<_Tp1>&) noexcept { } + + __attribute__((__always_inline__)) + + + + ~allocator() noexcept { } +# 214 "/usr/include/c++/13/bits/allocator.h" 3 + friend __attribute__((__always_inline__)) + bool + operator=3D=3D(const allocator&, const allocator&) noexcept + { return true; } + + + friend __attribute__((__always_inline__)) + bool + operator!=3D(const allocator&, const allocator&) noexcept + { return false; } + + + + }; + + + + + + + template + __attribute__((__always_inline__)) + inline bool + operator=3D=3D(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + + template + __attribute__((__always_inline__)) + inline bool + operator!=3D(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + + + + + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + +} +# 66 "/usr/include/c++/13/memory" 2 3 +# 1 "/usr/include/c++/13/bits/stl_tempbuf.h" 1 3 +# 61 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 +# 1 "/usr/include/c++/13/bits/stl_construct.h" 1 3 +# 61 "/usr/include/c++/13/bits/stl_construct.h" 3 +# 1 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 +=20=20=20=20=20=20=20 +# 63 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/include/c++/13/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 { = }; +# 125 "/usr/include/c++/13/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; + }; +# 149 "/usr/include/c++/13/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> { }; +# 209 "/usr/include/c++/13/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 __iterator_category_t + =3D typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter =3D + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value =3D _Base::value }; + }; + + + + + + + + +} +# 62 "/usr/include/c++/13/bits/stl_construct.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 +=20=20=20=20=20=20=20 +# 63 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/include/c++/13/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/13/bits/concept_check.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/concept_check.h" 3 +# 65 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/include/c++/13/debug/assertions.h" 1 3 +# 66 "/usr/include/c++/13/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) + { + +=20=20=20=20=20 + + typename iterator_traits<_InputIterator>::difference_type __n =3D 0; + while (__first !=3D __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) + { + +=20=20=20=20=20 + + 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) =3D = delete; +# 144 "/usr/include/c++/13/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) + { + +=20=20=20=20=20 + do { if (std::__is_constant_evaluated() && !bool(__n >=3D 0)) __buil= tin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + +=20=20=20=20=20 + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + +=20=20=20=20=20 + + if (__builtin_constant_p(__n) && __n =3D=3D 1) + ++__i; + else if (__builtin_constant_p(__n) && __n =3D=3D -1) + --__i; + else + __i +=3D __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) =3D delete; +# 217 "/usr/include/c++/13/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 =3D __= 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 =3D 1) + { + +=20=20=20=20=20 + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n =3D 1) + { + +=20=20=20=20=20 + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 63 "/usr/include/c++/13/bits/stl_construct.h" 2 3 +# 73 "/usr/include/c++/13/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(); + } +# 106 "/usr/include/c++/13/bits/stl_construct.h" 3 + template +=20=20=20 + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/include/c++/13/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/include/c++/13/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first !=3D __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + template + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + for (; __count > 0; (void)++__first, --__count) + std::_Destroy(std::__addressof(*__first)); + return __first; + } + }; + + template<> + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + inline _ForwardIterator + _Destroy_n(_ForwardIterator __first, _Size __count) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: + __destroy_n(__first, __count); + } + + + 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); + } + + + +} +# 62 "/usr/include/c++/13/bits/stl_tempbuf.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_pair.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_pair.h" 3 +# 1 "/usr/include/c++/13/bits/utility.h" 1 3 +# 36 "/usr/include/c++/13/bits/utility.h" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename =3D typename enable_if::value>::type, + size_t =3D tuple_size<_Tp>::value> + using __enable_if_has_tuple_size =3D _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 =3D tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t =3D typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type =3D const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type =3D volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type =3D const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz =3D sizeof...(_Types); + constexpr bool __found[__sz] =3D { __is_same(_Tp, _Types) ... }; + size_t __n =3D __sz; + for (size_t __i =3D 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n =3D __i; + } + } + return __n; + } +# 134 "/usr/include/c++/13/bits/utility.h" 3 + template + using tuple_element_t =3D typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/include/c++/13/bits/utility.h" 3 + using __type =3D _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 + + + + =3D integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence =3D integer_sequence; + + + template + using make_index_sequence =3D make_integer_sequence; + + + template + using index_sequence_for =3D make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() =3D default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() =3D default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() =3D default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v =3D false; + + template + inline constexpr bool __is_in_place_type_v> =3D t= rue; + + template + using __is_in_place_type =3D bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type =3D _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type =3D _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type =3D _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type =3D _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type =3D _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type =3D _Tp1; }; + + + + + + + +} +# 63 "/usr/include/c++/13/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 80 "/usr/include/c++/13/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() =3D defa= ult; }; + + + inline constexpr piecewise_construct_t piecewise_construct =3D + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + 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; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() =3D default; + ~__pair_base() =3D default; + __pair_base(const __pair_base&) =3D default; + __pair_base& operator=3D(const __pair_base&) =3D delete; + + }; +# 186 "/usr/include/c++/13/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&) =3D default; + constexpr pair(pair&&) =3D 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); + } +# 234 "/usr/include/c++/13/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/include/c++/13/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible= <_U2>> + ::value, bool>::type =3D 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 =3D false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP =3D _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=3Dtrue> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=3Dfalse> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP =3D _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=3Dtrue> + 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=3Dfalse> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/include/c++/13/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) =3D delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> =3D true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initi= alize 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> =3D false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initi= alize 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> =3D true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initi= alize 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> =3D false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initi= alize 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=3Dtrue> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=3Dfalse> + 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=3Dtrue> + 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=3Dfalse> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=3D(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first =3D __p.first; + second =3D __p.second; + return *this; + } + + pair& + operator=3D(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first =3D std::forward(__p.first); + second =3D std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=3D(const pair<_U1, _U2>& __p) + { + first =3D __p.first; + second =3D __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=3D(pair<_U1, _U2>&& __p) + { + first =3D std::forward<_U1>(__p.first); + second =3D std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/include/c++/13/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator=3D=3D(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first =3D=3D __y.first && __x.second =3D=3D __y.second; } +# 833 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + 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 + inline constexpr bool + operator!=3D(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x =3D=3D __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=3D(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=3D(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/include/c++/13/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); } +# 893 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) =3D delete; +# 919 "/usr/include/c++/13/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)); + } +# 942 "/usr/include/c++/13/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> =3D 2; + + template + inline constexpr size_t tuple_size_v> =3D 2; + + template + inline constexpr bool __is_pair =3D false; + + template + inline constexpr bool __is_pair> =3D true; + + + + 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::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__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::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1118 "/usr/include/c++/13/bits/stl_pair.h" 3 + +} +# 63 "/usr/include/c++/13/bits/stl_tempbuf.h" 2 3 +# 1 "/usr/include/c++/13/ext/numeric_traits.h" 1 3 +# 32 "/usr/include/c++/13/ext/numeric_traits.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/numeric_traits.h" 3 + +# 1 "/usr/include/c++/13/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +=20=20=20=20=20=20=20 +# 36 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/13/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 =3D bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; +# 184 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; +# 272 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = =3D 1 }; typedef __true_type __type; }; __extension__ template<> struct __i= s_integer { enum { __value =3D 1 }; typedef __true_type = __type; }; +# 289 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; +# 366 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; +# 470 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value =3D __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value =3D 0 }; + }; + + + template + struct __memcpyable + { + enum { __value =3D 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value =3D 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 =3D _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value =3D false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value =3D __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value =3D false; + }; +# 579 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value =3D true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value =3D false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value =3D false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value =3D 0 }; + typedef __false_type __type; + }; + + + + template +=20=20=20 + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 35 "/usr/include/c++/13/ext/numeric_traits.h" 2 3 +# 1 "/usr/include/c++/13/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/13/ext/type_traits.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/type_traits.h" 3 + + + + +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 =3D=3D 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; }; +# 225 "/usr/include/c++/13/ext/type_traits.h" 3 + template + using __promoted_t =3D decltype((typename __promote<_Tp>::__type(0) + = ...)); + + + + template + using __promote_2 =3D __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 =3D __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 =3D __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/include/c++/13/ext/type_traits.h" 3 + +} +} +# 36 "/usr/include/c++/13/ext/numeric_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width =3D __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed =3D (_Value)(-1) < 0; + static const int __digits + =3D __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max =3D __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min =3D __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; +# 137 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + using __int_traits =3D __numeric_traits_integer<_Tp>; +# 157 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 =3D (2 + (std::__are_same<_Value, fl= oat>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 113) *= 643L / 2136); + + + static const bool __is_signed =3D true; + static const int __digits10 =3D (std::__are_same<_Value, float>::__v= alue ? 6 : std::__are_same<_Value, double>::__value ? 15 : 33); + static const int __max_exponent10 =3D (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 + { }; +# 238 "/usr/include/c++/13/ext/numeric_traits.h" 3 + +} +# 64 "/usr/include/c++/13/bits/stl_tempbuf.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail + { + template + inline void + __return_temporary_buffer(_Tp* __p, + size_t __len __attribute__((__unused__))) + { + + ::operator delete(__p, __len * sizeof(_Tp)); + + + + } + } +# 101 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + [[__deprecated__]] + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) noexcept + { + const ptrdiff_t __max =3D + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len =3D __max; + + while (__len > 0) + { + _Tp* __tmp =3D static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp !=3D 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len =3D __len =3D=3D 1 ? 0 : ((__len + 1) / 2); + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 129 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p); } + + + + + + + template + class _Temporary_buffer + { + +=20=20=20=20=20 + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + + size_type + size() const + { return _M_len; } + + + size_type + requested_size() const + { return _M_original_len; } + + + iterator + begin() + { return _M_buffer; } + + + iterator + end() + { return _M_buffer + _M_len; } + + + + + + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::__detail::__return_temporary_buffer(_M_buffer, _M_len); + } + + private: + + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=3D(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if (__first =3D=3D __last) + return; + + _Pointer __cur =3D __first; + if (true) + { + std::_Construct(std::__addressof(*__first), + std::move(*__seed)); + _Pointer __prev =3D __cur; + ++__cur; + for(; __cur !=3D __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + std::move(*__prev)); + *__seed =3D std::move(*__prev); + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 247 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) + : _M_original_len(__original_len), _M_len(0), _M_buffer(0) + { + std::pair __p( + std::get_temporary_buffer(_M_original_len)); + + if (__p.first) + { + if (true) + { + std::__uninitialized_construct_buf(__p.first, __p.first + __p.secon= d, + __seed); + _M_buffer =3D __p.first; + _M_len =3D __p.second; + } + if (false) + { + std::__detail::__return_temporary_buffer(__p.first, __p.second); + ; + } + } + } +#pragma GCC diagnostic pop + + +} +# 67 "/usr/include/c++/13/memory" 2 3 + + +# 1 "/usr/include/c++/13/bits/stl_uninitialized.h" 1 3 +# 63 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 +# 1 "/usr/include/c++/13/bits/stl_algobase.h" 1 3 +# 67 "/usr/include/c++/13/bits/stl_algobase.h" 3 +# 1 "/usr/include/c++/13/bits/stl_iterator.h" 1 3 +# 67 "/usr/include/c++/13/bits/stl_iterator.h" 3 +# 1 "/usr/include/c++/13/bits/ptr_traits.h" 1 3 +# 49 "/usr/include/c++/13/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type =3D __undefined; }; + + template class _SomeTemplate, typename _= Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type =3D _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 =3D _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type =3D typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t =3D typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer =3D _Ptr; + using element_type =3D _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 =3D _Tp*; + using element_type =3D _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 =3D typename _Tp::difference_type; + + template + using __rebind =3D __type_identity>; + + public: + + using pointer =3D _Ptr; + + + using element_type =3D _Elt; + + + using difference_type =3D __detected_or_t; + + + template + using rebind =3D 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<_P= tr>> + { }; + + + + + + + + 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 =3D _Up*; + }; + + + template + using __ptr_rebind =3D typename pointer_traits<_Ptr>::template rebind<= _Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not 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->()); } +# 266 "/usr/include/c++/13/bits/ptr_traits.h" 3 + +} +# 68 "/usr/include/c++/13/bits/stl_iterator.h" 2 3 +# 88 "/usr/include/c++/13/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 109 "/usr/include/c++/13/bits/stl_iterator.h" 3 +=20 +# 109 "/usr/include/c++/13/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 131 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_catego= ry, + 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; +# 150 "/usr/include/c++/13/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; +# 181 "/usr/include/c++/13/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=3D(const reverse_iterator&) =3D default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=3D(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current =3D __x.current)) + { + current =3D __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 258 "/usr/include/c++/13/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp =3D current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp =3D current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp =3D *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp =3D *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=3D(difference_type __n) + { + current -=3D __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=3D(difference_type __n) + { + current +=3D __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 418 "/usr/include/c++/13/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->(); } + }; +# 441 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator=3D=3D(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() =3D=3D __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!=3D(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x =3D=3D __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<=3D(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=3D(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator=3D=3D(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() =3D=3D __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!=3D(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() !=3D __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<=3D(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >=3D __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=3D(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <=3D __y.base(); } +# 618 "/usr/include/c++/13/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); } +# 662 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template +=20=20=20 + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template +=20=20=20 + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 693 "/usr/include/c++/13/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)) { } +# 731 "/usr/include/c++/13/bits/stl_iterator.h" 3 +=20=20=20=20=20 + back_insert_iterator& + operator=3D(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + +=20=20=20=20=20 + back_insert_iterator& + operator=3D(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + +=20=20=20=20=20 + back_insert_iterator& + operator++() + { return *this; } + + +=20=20=20=20=20 + back_insert_iterator + operator++(int) + { return *this; } + }; +# 778 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 794 "/usr/include/c++/13/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)) { } +# 832 "/usr/include/c++/13/bits/stl_iterator.h" 3 +=20=20=20=20=20 + front_insert_iterator& + operator=3D(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + +=20=20=20=20=20 + front_insert_iterator& + operator=3D(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + +=20=20=20=20=20 + front_insert_iterator& + operator++() + { return *this; } + + +=20=20=20=20=20 + front_insert_iterator + operator++(int) + { return *this; } + }; +# 879 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 899 "/usr/include/c++/13/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; +# 924 "/usr/include/c++/13/bits/stl_iterator.h" 3 +=20=20=20=20=20 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 960 "/usr/include/c++/13/bits/stl_iterator.h" 3 +=20=20=20=20=20 + insert_iterator& + operator=3D(const typename _Container::value_type& __value) + { + iter =3D container->insert(iter, __value); + ++iter; + return *this; + } + +=20=20=20=20=20 + insert_iterator& + operator=3D(typename _Container::value_type&& __value) + { + iter =3D container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + +=20=20=20=20=20 + insert_iterator& + operator++() + { return *this; } + + +=20=20=20=20=20 + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1019 "/usr/include/c++/13/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"))) +{ + +# 1042 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + =3D 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; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1090 "/usr/include/c++/13/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + +=20=20=20=20=20 + reference + operator*() const noexcept + { return *_M_current; } + +=20=20=20=20=20 + pointer + operator->() const noexcept + { return _M_current; } + +=20=20=20=20=20 + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + +=20=20=20=20=20 + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + +=20=20=20=20=20 + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + +=20=20=20=20=20 + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + +=20=20=20=20=20 + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + +=20=20=20=20=20 + __normal_iterator& + operator+=3D(difference_type __n) noexcept + { _M_current +=3D __n; return *this; } + +=20=20=20=20=20 + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + +=20=20=20=20=20 + __normal_iterator& + operator-=3D(difference_type __n) noexcept + { _M_current -=3D __n; return *this; } + +=20=20=20=20=20 + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + +=20=20=20=20=20 + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1210 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() =3D=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() =3D=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=3D(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() !=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=3D(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() !=3D __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=3D(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=3D(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=3D(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >=3D __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=3D(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >=3D __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline 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__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_t= ype + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::differenc= e_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template +=20=20=20 + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1417 "/usr/include/c++/13/bits/stl_iterator.h" 3 + namespace __detail + { +# 1433 "/usr/include/c++/13/bits/stl_iterator.h" 3 + } +# 1444 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type =3D iterator_traits<_Iterator>; + + using __base_ref =3D typename __traits_type::reference; + + + template + friend class move_iterator; +# 1483 "/usr/include/c++/13/bits/stl_iterator.h" 3 + public: + using iterator_type =3D _Iterator; +# 1497 "/usr/include/c++/13/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 + =3D __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=3D(const move_iterator<_Iter>& __i) + { + _M_current =3D __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1555 "/usr/include/c++/13/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 =3D *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp =3D *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=3D(difference_type __n) + { + _M_current +=3D __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=3D(difference_type __n) + { + _M_current -=3D __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1669 "/usr/include/c++/13/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator=3D=3D(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() =3D=3D __y.base(); } +# 1690 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=3D(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x =3D=3D __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<=3D(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>=3D(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator=3D=3D(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() =3D=3D __y.base(); } +# 1756 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=3D(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x =3D=3D __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<=3D(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>=3D(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>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2585 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template +=20=20=20 + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value =3D 1 }; + typedef __true_type __type; + }; + + template +=20=20=20 + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2617 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + using __iter_key_t =3D remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + =3D typename iterator_traits<_InputIterator>::value_type::second_typ= e; + + template + struct pair; + + template + using __iter_to_alloc_t + =3D pair, __iter_val_t<_InputIter= ator>>; + + + +} +# 68 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/13/debug/debug.h" 1 3 +# 48 "/usr/include/c++/13/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/13/bits/predefined_ops.h" 1 3 +# 35 "/usr/include/c++/13/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() =3D default; + + + + +=20=20=20 + explicit + _Iter_less_val(_Iter_less_iter) { } + + template +=20=20=20=20=20 + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + +=20 + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + +=20 + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() =3D default; + + + + +=20=20=20 + explicit + _Val_less_iter(_Iter_less_iter) { } + + template +=20=20=20=20=20 + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + +=20 + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + +=20 + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template +=20=20=20=20=20 + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 =3D=3D *__it2; } + }; + +=20 + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template +=20=20=20=20=20 + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it =3D=3D __val; } + }; + +=20 + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + +=20 + 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; + +=20=20=20=20=20 + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + +=20=20=20=20=20 + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + +=20=20=20=20=20 + 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 +=20=20=20 + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template +=20=20=20 + 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; + +=20=20=20=20=20 + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + +=20=20=20=20=20 + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + +=20=20=20=20=20 + 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 +=20=20=20 + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template +=20=20=20 + 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; + +=20=20=20=20=20 + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it =3D=3D _M_value; } + }; + + template +=20=20=20 + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + +=20=20=20=20=20 + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 =3D=3D *_M_it1; } + }; + + template +=20=20=20 + 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; + +=20=20=20=20=20 + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template +=20=20=20 + 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; + +=20=20=20=20=20 + _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> +=20=20=20 + __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; + +=20=20=20=20=20 + _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 +=20=20=20 + 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; + +=20=20=20=20=20 + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template +=20=20=20 + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/include/c++/13/bit" 1 3 +# 32 "/usr/include/c++/13/bit" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/bit" 3 +# 55 "/usr/include/c++/13/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 149 "/usr/include/c++/13/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd =3D __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) =3D=3D 0) + { + + + constexpr unsigned __uNd =3D _Nd; + const unsigned __r =3D __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r =3D __s % _Nd; + if (__r =3D=3D 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 =3D __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) =3D=3D 0) + { + + + constexpr unsigned __uNd =3D _Nd; + const unsigned __r =3D __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r =3D __s % _Nd; + if (__r =3D=3D 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 =3D __int_traits<_Tp>::__digits; + + if (__x =3D=3D 0) + return _Nd; + + constexpr auto _Nd_ull =3D __int_traits::__digit= s; + constexpr auto _Nd_ul =3D __int_traits::__digits; + constexpr auto _Nd_u =3D __int_traits::__digits; + + if constexpr (_Nd <=3D _Nd_u) + { + constexpr int __diff =3D _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <=3D _Nd_ul) + { + constexpr int __diff =3D _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <=3D _Nd_ull) + { + constexpr int __diff =3D _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <=3D (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high =3D __x >> _Nd_ull; + if (__high !=3D 0) + { + constexpr int __diff =3D (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull =3D __int_traits::__max; + unsigned long long __low =3D __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + 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 =3D __int_traits<_Tp>::__digits; + + if (__x =3D=3D 0) + return _Nd; + + constexpr auto _Nd_ull =3D __int_traits::__digit= s; + constexpr auto _Nd_ul =3D __int_traits::__digits; + constexpr auto _Nd_u =3D __int_traits::__digits; + + if constexpr (_Nd <=3D _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <=3D _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <=3D _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <=3D (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull =3D __int_traits::__max; + unsigned long long __low =3D __x & __max_ull; + if (__low !=3D 0) + return __builtin_ctzll(__low); + unsigned long long __high =3D __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd =3D __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull =3D __int_traits::__digit= s; + constexpr auto _Nd_ul =3D __int_traits::__digits; + constexpr auto _Nd_u =3D __int_traits::__digits; + + if constexpr (_Nd <=3D _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <=3D _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <=3D _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <=3D (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull =3D __int_traits::__max; + unsigned long long __low =3D __x & __max_ull; + unsigned long long __high =3D __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) =3D=3D 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd =3D __int_traits<_Tp>::__digits; + if (__x =3D=3D 0 || __x =3D=3D 1) + return 1; + auto __shift_exponent =3D _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent !=3D = __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type =3D decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp =3D sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |=3D (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd =3D __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x =3D=3D 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd =3D __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 478 "/usr/include/c++/13/bit" 3 + +} +# 77 "/usr/include/c++/13/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) =3D=3D sizeof(_Up), "can be compared with = memcmp"); +# 108 "/usr/include/c++/13/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + +=20=20=20=20=20 + +=20=20=20=20=20 +# 185 "/usr/include/c++/13/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + for (; __first1 !=3D __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + +=20=20=20=20=20 + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + +=20=20=20=20=20 + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template +=20=20=20 + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template +=20=20=20 + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template +=20=20=20 + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first !=3D __last; ++__result, (void)++__first) + *__result =3D *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first !=3D __last; ++__result, (void)++__first) + *__result =3D std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n =3D __last - __first; __n > 0; --__n) + { + *__result =3D *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to =3D *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n =3D __last - __first; __n > 0; --__n) + { + *__result =3D std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to =3D std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num =3D __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num =3D=3D 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + 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*>); + + + template +=20=20=20 + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + 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 +=20=20=20 + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template +=20=20=20 + 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>&); + + template +=20=20=20 + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result =3D *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + 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); +# 621 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _OI + copy(_II __first, _II __last, _OI __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _OI + move(_II __first, _II __last, _OI __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first !=3D __last) + *--__result =3D *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first !=3D __last) + *--__result =3D std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n =3D __last - __first; + for (; __n > 0; --__n) + *--__result =3D *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n =3D __last - __first; + for (; __n > 0; --__n) + *--__result =3D std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num =3D __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num =3D=3D 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template +=20=20=20 + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template +=20=20=20 + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __resu= lt); } + + 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 +=20=20=20 + 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>&); +# 854 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template +=20=20=20 + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first !=3D __last; ++__first) + *__first =3D __value; + } + + template +=20=20=20 + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp =3D __value; + for (; __first !=3D __last; ++__first) + *__first =3D __tmp; + } + + + template +=20=20=20 + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp =3D __c; +# 950 "/usr/include/c++/13/bits/stl_algobase.h" 3 + if (const size_t __len =3D __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template +=20=20=20 + 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&); + +=20 + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template +=20=20=20 + 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&); +# 997 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __v= alue) + { + +=20=20=20=20=20 + + ; + + std::__fill_a(__first, __last, __value); + } + + + 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; } +# 1049 "/usr/include/c++/13/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; } + + + + + + template +=20=20=20 + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::_= _type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first =3D __value; + return __first; + } + + template +=20=20=20 + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__= type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp =3D __value; + for (; __n > 0; --__n, (void) ++__first) + *__first =3D __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __fi= rst, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template +=20=20=20 + 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 +=20=20=20 + 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 +=20=20=20 + 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 <=3D 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + +=20=20=20=20=20 + + 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 !=3D __last1; ++__first1, (void) ++__first2) + if (!(*__first1 =3D=3D *__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 =3D (__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 +=20=20=20 + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple =3D ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template +=20=20=20 + 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 !=3D __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 =3D __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 =3D __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template +=20=20=20 + 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 =3D __rai_type::__newlast1(__first1, __last1, __first2, __la= st2); + for (; __first1 !=3D __last1 && __rai_type::__cnd2(__first2, __last2= ); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 =3D=3D __last1 && __first2 !=3D __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 !=3D __last1) + { + if (__first2 =3D=3D __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 =3D=3D __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 =3D __last1 - __first1; + const size_t __len2 =3D __last2 - __first2; + if (const size_t __len =3D std::min(__len1, __len2)) + if (int __result =3D std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template +=20=20=20 + 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 =3D + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __la= st1, + __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 +=20=20=20 + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first= 1), + 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 +=20=20=20 + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len =3D std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half =3D __len >> 1; + _ForwardIterator __middle =3D __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first =3D __middle; + ++__first; + __len =3D __len - __half - 1; + } + else + __len =3D __half; + } + return __first; + } +# 1495 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + 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; +# 1531 "/usr/include/c++/13/bits/stl_algobase.h" 3 + } + + +# 1547 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + ; + + for (; __first1 !=3D __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template +=20=20=20 + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag =3D random_access_iterator_tag; + using _Cat1 =3D typename iterator_traits<_II1>::iterator_category; + using _Cat2 =3D typename iterator_traits<_II2>::iterator_category; + using _RAIters =3D __and_, is_same<_Cat2, _RA= Tag>>; + if (_RAIters()) + { + auto __d1 =3D std::distance(__first1, __last1); + auto __d2 =3D std::distance(__first2, __last2); + if (__d1 !=3D __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 !=3D __last1 && __first2 !=3D __last2; + ++__first1, (void)++__first2) + if (!(*__first1 =3D=3D *__first2)) + return false; + return __first1 =3D=3D __last1 && __first2 =3D=3D __last2; + } + + + template +=20=20=20 + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag =3D random_access_iterator_tag; + using _Cat1 =3D typename iterator_traits<_II1>::iterator_category; + using _Cat2 =3D typename iterator_traits<_II2>::iterator_category; + using _RAIters =3D __and_, is_same<_Cat2, _RA= Tag>>; + if (_RAIters()) + { + auto __d1 =3D std::distance(__first1, __last1); + auto __d2 =3D std::distance(__first2, __last2); + if (__d1 !=3D __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 !=3D __last1 && __first2 !=3D __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 =3D=3D __last1 && __first2 =3D=3D __last2; + } +# 1668 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 !=3D __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template +=20=20=20 + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template +=20=20=20 + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first !=3D __last && !__pred(__first)) + ++__first; + return __first; + } + + + template +=20=20=20 + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count =3D (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template +=20=20=20 + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template +=20=20=20 + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate _= _pred) + { + typename iterator_traits<_InputIterator>::difference_type __n =3D 0; + for (; __first !=3D __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template +=20=20=20 + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first =3D std::__find_if(__first, __last, __pred); + if (__first =3D=3D __last) + return __first; + _ForwardIterator __result =3D __first; + ++__first; + for (; __first !=3D __last; ++__first) + if (!__pred(__first)) + { + *__result =3D std::move(*__first); + ++__result; + } + return __result; + } + + + template +=20=20=20 + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 !=3D __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 =3D=3D __last1) + return true; + + + + _ForwardIterator2 __last2 =3D __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan =3D __first1; __scan !=3D __last1; ++_= _scan) + { + if (__scan !=3D std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + =3D std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 =3D=3D __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + !=3D __matches) + return false; + } + return true; + } +# 2204 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template +=20=20=20 + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 64 "/usr/include/c++/13/bits/stl_uninitialized.h" 2 3 +# 1 "/usr/include/c++/13/ext/alloc_traits.h" 1 3 +# 32 "/usr/include/c++/13/ext/alloc_traits.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/alloc_traits.h" 3 + +# 1 "/usr/include/c++/13/bits/alloc_traits.h" 1 3 +# 43 "/usr/include/c++/13/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + 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 =3D 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 =3D typename _Tp::pointer; + template + using __c_pointer =3D typename _Tp::const_pointer; + template + using __v_pointer =3D typename _Tp::void_pointer; + template + using __cv_pointer =3D typename _Tp::const_void_pointer; + template + using __pocca =3D typename _Tp::propagate_on_container_copy_assignme= nt; + template + using __pocma =3D typename _Tp::propagate_on_container_move_assignme= nt; + template + using __pocs =3D typename _Tp::propagate_on_container_swap; + template + using __equal =3D __type_identity; + }; + + template + using __alloc_rebind + =3D typename __allocator_traits_base::template __rebind<_Alloc, _Up>= ::type; +# 104 "/usr/include/c++/13/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 =3D __detected_or_t; + + private: + + template class _Func, typename _Tp, typename =3D = void> + struct _Ptr + { + using type =3D typename pointer_traits::template rebind<_Tp>; + }; + + template class _Func, typename _Tp> + struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> + { + using type =3D _Func<_Alloc>; + }; + + + template + struct _Diff + { using type =3D typename pointer_traits<_PtrT>::difference_type; }; + + template + struct _Diff<_A2, _PtrT, __void_t> + { using type =3D typename _A2::difference_type; }; + + + template + struct _Size : make_unsigned<_DiffT> { }; + + template + struct _Size<_A2, _DiffT, __void_t> + { using type =3D typename _A2::size_type; }; + + public: + + + + + + + using const_pointer =3D typename _Ptr<__c_pointer, const value_type>= ::type; + + + + + + + + using void_pointer =3D typename _Ptr<__v_pointer, void>::type; + + + + + + + + using const_void_pointer =3D typename _Ptr<__cv_pointer, const void>= ::type; + + + + + + + + using difference_type =3D typename _Diff<_Alloc, pointer>::type; + + + + + + + + using size_type =3D typename _Size<_Alloc, difference_type>::type; + + + + + + + + using propagate_on_container_copy_assignment + =3D __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + =3D __detected_or_t; + + + + + + + + using propagate_on_container_swap + =3D __detected_or_t; + + + + + + + + using is_always_equal + =3D typename __detected_or_t, __equal, _Alloc>::type; + + template + using rebind_alloc =3D __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits =3D allocator_traits>; + + private: + template + static constexpr auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static constexpr pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type =3D decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + =3D typename __construct_helper<_Tp, _Args...>::type; + + template + static constexpr _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static constexpr + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) + { + + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + + + + } + + template + static constexpr auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + noexcept(noexcept(__a.destroy(__p))) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static constexpr void + _S_destroy(_Alloc2&, _Tp* __p, ...) + noexcept(std::is_nothrow_destructible<_Tp>::value) + { std::_Destroy(__p); } + + template + static constexpr auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static constexpr size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static constexpr auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static constexpr _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 331 "/usr/include/c++/13/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 346 "/usr/include/c++/13/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 358 "/usr/include/c++/13/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 373 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + static auto + construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(_S_construct(__a, __p, + std::forward<_Args>(__args)...))) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 389 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + static void + destroy(_Alloc& __a, _Tp* __p) + noexcept(noexcept(_S_destroy(__a, __p, 0))) + { _S_destroy(__a, __p, 0); } +# 403 "/usr/include/c++/13/bits/alloc_traits.h" 3 + static size_type + max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 415 "/usr/include/c++/13/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; +# 427 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + struct allocator_traits> + { + + using allocator_type =3D allocator<_Tp>; + + + using value_type =3D _Tp; + + + using pointer =3D _Tp*; + + + using const_pointer =3D const _Tp*; + + + using void_pointer =3D void*; + + + using const_void_pointer =3D const void*; + + + using difference_type =3D std::ptrdiff_t; + + + using size_type =3D std::size_t; + + + using propagate_on_container_copy_assignment =3D false_type; + + + using propagate_on_container_move_assignment =3D true_type; + + + using propagate_on_container_swap =3D false_type; + + + using is_always_equal =3D true_type; + + template + using rebind_alloc =3D allocator<_Up>; + + template + using rebind_traits =3D allocator_traits>; +# 479 "/usr/include/c++/13/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 494 "/usr/include/c++/13/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hi= nt) + { + + return __a.allocate(__n, __hint); + + + + } +# 513 "/usr/include/c++/13/bits/alloc_traits.h" 3 + [[__gnu__::__always_inline__]] + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 529 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, + _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { + + __a.construct(__p, std::forward<_Args>(__args)...); + + + + } +# 550 "/usr/include/c++/13/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__))) noex= cept + { + + return __a.max_size(); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template<> + struct allocator_traits> + { + + using allocator_type =3D allocator; + + + using value_type =3D void; + + + using pointer =3D void*; + + + using const_pointer =3D const void*; + + + using void_pointer =3D void*; + + + using const_void_pointer =3D const void*; + + + using difference_type =3D std::ptrdiff_t; + + + using size_type =3D std::size_t; + + + using propagate_on_container_copy_assignment =3D false_type; + + + using propagate_on_container_move_assignment =3D true_type; + + + using propagate_on_container_swap =3D false_type; + + + using is_always_equal =3D true_type; + + template + using rebind_alloc =3D allocator<_Up>; + + template + using rebind_traits =3D allocator_traits>; + + + static void* + allocate(allocator_type&, size_type, const void* =3D nullptr) =3D de= lete; + + + static void + deallocate(allocator_type&, void*, size_type) =3D delete; +# 655 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type&, _Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { std::_Construct(__p, std::forward<_Args>(__args)...); } +# 669 "/usr/include/c++/13/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&) =3D delete; + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; +# 707 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + using __traits =3D allocator_traits<_Alloc>; + using __pocca =3D + typename __traits::propagate_on_container_copy_assignment::type; + + if constexpr (__pocca::value) + __one =3D __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); + } +# 744 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + using __traits =3D allocator_traits<_Alloc>; + using __pocma + =3D typename __traits::propagate_on_container_move_assignment::type; + + if constexpr (__pocma::value) + __one =3D std::move(__two); + + + + } +# 775 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + using __traits =3D allocator_traits<_Alloc>; + using __pocs =3D typename __traits::propagate_on_container_swap::typ= e; + + if constexpr (__pocs::value) + { + using std::swap; + swap(__one, __two); + } + + + + } + + template, + typename =3D 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 + =3D typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; + + template + using _RequireNotAllocator + =3D typename enable_if::value, _Alloc>::type; +# 872 "/usr/include/c++/13/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 !=3D __two) + swap(__one, __two); + } + }; + + + template, + is_nothrow_move_constructible>::valu= e> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { +=20=20=20=20=20 + static bool + _S_do_it(_Tp& __c) noexcept + { +# 913 "/usr/include/c++/13/bits/alloc_traits.h" 3 + return false; + + } + }; +# 925 "/usr/include/c++/13/bits/alloc_traits.h" 3 + template +=20=20=20 + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + for (; __first !=3D __last; ++__first) + + + + allocator_traits<_Allocator>::destroy(__alloc, + std::__addressof(*__first)); + + } + + + template + __attribute__((__always_inline__)) + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + _Destroy(__first, __last); + } + + + + +} +# 35 "/usr/include/c++/13/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 + =3D 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; }; +# 180 "/usr/include/c++/13/ext/alloc_traits.h" 3 + }; + + +} +# 65 "/usr/include/c++/13/bits/stl_uninitialized.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 81 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + constexpr bool + __check_constructible() + { + + + + + + static_assert(is_constructible<_ValueType, _Tp>::value, + "result type must be constructible from input type"); + + return true; + } +# 110 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template +=20=20=20 + _ForwardIterator + __do_uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + _ForwardIterator __cur =3D __result; + if (true) + { + for (; __first !=3D __last; ++__first, (void)++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + if (false) + { + std::_Destroy(__result, __cur); + ; + } + } + + template + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::__do_uninit_copy(__first, __last, __result); } + }; + + template<> + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::copy(__first, __last, __result); } + }; +# 161 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + + + + + const bool __can_memmove =3D __is_trivial(_ValueType1); + + + + + using _From =3D decltype(*__first); + + const bool __assignable + =3D __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && = std::__check_constructible<_ValueType2, _From>(); + + return std::__uninitialized_copy<__can_memmove && __assignable>:: + __uninit_copy(__first, __last, __result); + } + + + + template + void + __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __cur !=3D __last; ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + + template + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::__do_uninit_fill(__first, __last, __x); } + }; + + template<> + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::fill(__first, __last, __x); } + }; +# 239 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + =3D __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) = && std::__check_constructible<_ValueType, const _Tp&>(); + + std::__uninitialized_fill<__can_fill>:: + __uninit_fill(__first, __last, __x); + } + + + + template +=20=20=20 + _ForwardIterator + __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + return __cur; + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + + template + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::__do_uninit_fill_n(__first, __n, __x); } + }; + + template<> + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::fill_n(__first, __n, __x); } + }; +# 310 "/usr/include/c++/13/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; + + + + const bool __can_fill + =3D __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) = && std::__check_constructible<_ValueType, const _Tp&>() + + + + && __is_integer<_Size>::__value; + + return __uninitialized_fill_n<__can_fill>:: + __uninit_fill_n(__first, __n, __x); + } +# 340 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template +=20=20=20 + _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + _ForwardIterator __cur =3D __result; + if (true) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first !=3D __last; ++__first, (void)++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), *__first); + return __cur; + } + if (false) + { + std::_Destroy(__result, __cur, __alloc); + ; + } + } + + + template +=20=20=20 + inline _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, allocator<_Tp>&) + { + + + + + return std::uninitialized_copy(__first, __last, __result); + } + + + template +=20=20=20 + 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 +=20=20=20 + 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 +=20=20=20 + void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __la= st, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur =3D __first; + if (true) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur !=3D __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + if (false) + { + std::_Destroy(__first, __cur, __alloc); + ; + } + } + + + template +=20=20=20 + inline void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __la= st, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + std::uninitialized_fill(__first, __last, __x); + } + + + template +=20=20=20=20 + _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur =3D __first; + if (true) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + return __cur; + } + if (false) + { + std::_Destroy(__first, __cur, __alloc); + ; + } + } + + + template +=20=20=20 + inline _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + return std::uninitialized_fill_n(__first, __n, __x); + } +# 485 "/usr/include/c++/13/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 =3D std::__uninitialized_copy_a(__first1, __l= ast1, + __result, + __alloc); + if (true) + { + return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); + } + if (false) + { + std::_Destroy(__result, __mid, __alloc); + ; + } + } + + + + + + template + inline _ForwardIterator + __uninitialized_move_copy(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid =3D std::__uninitialized_move_a(__first1, __l= ast1, + __result, + __alloc); + if (true) + { + return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); + } + if (false) + { + std::_Destroy(__result, __mid, __alloc); + ; + } + } + + + + + 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); + if (true) + { + return std::__uninitialized_move_a(__first, __last, __mid, __alloc); + } + if (false) + { + std::_Destroy(__result, __mid, __alloc); + ; + } + } + + + + + template + inline void + __uninitialized_move_fill(_InputIterator __first1, _InputIterator __la= st1, + _ForwardIterator __first2, + _ForwardIterator __last2, const _Tp& __x, + _Allocator& __alloc) + { + _ForwardIterator __mid2 =3D std::__uninitialized_move_a(__first1, __= last1, + __first2, + __alloc); + if (true) + { + std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); + } + if (false) + { + std::_Destroy(__first2, __mid2, __alloc); + ; + } + } +# 592 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __cur !=3D __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + }; + + template<> + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + if (__first =3D=3D __last) + return; + + typename iterator_traits<_ForwardIterator>::value_type* __val + =3D std::__addressof(*__first); + std::_Construct(__val); + if (++__first !=3D __last) + std::fill(__first, __last, *__val); + } + }; + + template + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur)); + return __cur; + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + }; + + 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 + =3D std::__addressof(*__first); + std::_Construct(__val); + ++__first; + __first =3D 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 =3D is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default(__first, __last); + } + + + + template +=20=20=20 + inline _ForwardIterator + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + constexpr bool __can_fill + =3D __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) + { + _ForwardIterator __cur =3D __first; + if (true) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur !=3D __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + if (false) + { + std::_Destroy(__first, __cur, __alloc); + ; + } + } + + + 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) + { + _ForwardIterator __cur =3D __first; + if (true) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + return __cur; + } + if (false) + { + std::_Destroy(__first, __cur, __alloc); + ; + } + } + + + + + template +=20=20=20 + 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) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __cur !=3D __last; ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + }; + + template<> + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + } + }; + + template + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur =3D __first; + if (true) + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + return __cur; + } + if (false) + { + std::_Destroy(__first, __cur); + ; + } + } + }; + + 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) + { + _ForwardIterator __cur =3D __result; + if (true) + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + if (false) + { + std::_Destroy(__result, __cur); + ; + } + } + + 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) + { + _ForwardIterator __cur =3D __result; + if (true) + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return {__first, __cur}; + } + if (false) + { + std::_Destroy(__result, __cur); + ; + } + } + + template + inline pair<_RandomAccessIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { + auto __second_res =3D uninitialized_copy(__first, __first + __n, __r= esult); + auto __first_res =3D std::next(__first, __n); + return {__first_res, __second_res}; + } +# 941 "/usr/include/c++/13/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)); + } +# 970 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_default_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + __uninitialized_default_novalue(__first, __last); + } +# 985 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_default_construct_n(_ForwardIterator __first, _Size __co= unt) + { + return __uninitialized_default_novalue_n(__first, __count); + } + + + + + + + + template + inline void + uninitialized_value_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + return __uninitialized_default(__first, __last); + } +# 1013 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_value_construct_n(_ForwardIterator __first, _Size __coun= t) + { + return __uninitialized_default_n(__first, __count); + } +# 1028 "/usr/include/c++/13/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); + } +# 1046 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + template + inline pair<_InputIterator, _ForwardIterator> + uninitialized_move_n(_InputIterator __first, _Size __count, + _ForwardIterator __result) + { + auto __res =3D std::__uninitialized_copy_n_pair + (std::make_move_iterator(__first), + __count, __result); + return {__res.first.base(), __res.second}; + } + + + + + + template +=20=20=20 + 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 + : is_trivial<_Tp> { }; + + template +=20=20=20 + 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 =3D __result; + for (; __first !=3D __last; ++__first, (void)++__cur) + std::__relocate_object_a(std::__addressof(*__cur), + std::__addressof(*__first), __alloc); + return __cur; + } + + + template +=20=20=20 + inline __enable_if_t::value, _Tp*> + __relocate_a_1(_Tp* __first, _Tp* __last, + _Tp* __result, + [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept + { + ptrdiff_t __count =3D __last - __first; + if (__count > 0) + { +# 1126 "/usr/include/c++/13/bits/stl_uninitialized.h" 3 + __builtin_memmove(__result, __first, __count * sizeof(_Tp)); + } + return __result + __count; + } + + + template +=20=20=20 + 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); + } + + + + + + + +} +# 70 "/usr/include/c++/13/memory" 2 3 +# 1 "/usr/include/c++/13/bits/stl_raw_storage_iter.h" 1 3 +# 59 "/usr/include/c++/13/bits/stl_raw_storage_iter.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +=20 +# 64 "/usr/include/c++/13/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=3D(const _Tp& __element) + { + std::_Construct(std::__addressof(*_M_iter), __element); + return *this; + } + + + + + raw_storage_iterator& + operator=3D(_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 =3D *this; + ++_M_iter; + return __tmp; + } + + + + _OutputIterator base() const { return _M_iter; } + }; +#pragma GCC diagnostic pop + + +} +# 71 "/usr/include/c++/13/memory" 2 3 + + + +# 1 "/usr/include/c++/13/bits/align.h" 1 3 +# 36 "/usr/include/c++/13/bits/align.h" 3 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdint.h" 1 3 4 +# 9 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdint.h" 3 4 +# 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 + + + + + +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; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/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; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 10 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdint.h" 2 3 4 +# 37 "/usr/include/c++/13/bits/align.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 61 "/usr/include/c++/13/bits/align.h" 3 +inline void* +align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexce= pt +{ + if (__space < __size) + return nullptr; + const auto __intptr =3D reinterpret_cast(__ptr); + const auto __aligned =3D (__intptr - 1u + __align) & -__align; + const auto __diff =3D __aligned - __intptr; + if (__diff > (__space - __size)) + return nullptr; + else + { + __space -=3D __diff; + return __ptr =3D reinterpret_cast(__aligned); + } +} +# 108 "/usr/include/c++/13/bits/align.h" 3 + +} +# 75 "/usr/include/c++/13/memory" 2 3 +# 1 "/usr/include/c++/13/bits/uses_allocator.h" 1 3 +# 35 "/usr/include/c++/13/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + struct __erased_type { }; + + + + + template + using __is_erased_or_convertible + =3D __or_, is_same<_Tp, __erased_type>>; + + + struct allocator_arg_t { explicit allocator_arg_t() =3D default; }; + + inline constexpr allocator_arg_t allocator_arg =3D + 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>::ty= pe + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=3D(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...>::v= alue, + __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 =3D + __uses_alloc::value, _Tp, _Alloc, _Args.= ..>; + + template +=20=20=20 + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a =3D std::__addressof(__a); + return __ret; + } + + template + void + __use_alloc(const _Alloc&&) =3D delete; + + + template + inline constexpr bool uses_allocator_v =3D + 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 =3D + __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 =3D + __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::va= lue; + + + template + void __uses_allocator_construct_impl(__uses_alloc0 __a, _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)...); + } + + + +} +# 76 "/usr/include/c++/13/memory" 2 3 + + +# 1 "/usr/include/c++/13/bits/unique_ptr.h" 1 3 +# 36 "/usr/include/c++/13/bits/unique_ptr.h" 3 +# 1 "/usr/include/c++/13/tuple" 1 3 +# 32 "/usr/include/c++/13/tuple" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/tuple" 3 +# 41 "/usr/include/c++/13/tuple" 3 +# 1 "/usr/include/c++/13/bits/invoke.h" 1 3 +# 33 "/usr/include/c++/13/bits/invoke.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/invoke.h" 3 +# 42 "/usr/include/c++/13/bits/invoke.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 53 "/usr/include/c++/13/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 =3D __invoke_result<_Callable, _Args...>; + using __type =3D typename __result::type; + using __tag =3D typename __result::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(_= _fn), + std::forward<_Args>(__args)...); + } + + + + template + constexpr enable_if_t, _Re= s> + __invoke_r(_Callable&& __fn, _Args&&... __args) + noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) + { + using __result =3D __invoke_result<_Callable, _Args...>; + using __type =3D typename __result::type; + using __tag =3D 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)...); + } +# 155 "/usr/include/c++/13/bits/invoke.h" 3 + +} +# 42 "/usr/include/c++/13/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 + =3D __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&) =3D default; + constexpr _Head_base(_Head_base&&) =3D default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + +=20=20=20=20=20 + _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; + }; +# 187 "/usr/include/c++/13/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&) =3D default; + constexpr _Head_base(_Head_base&&) =3D default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + +=20=20=20=20=20 + _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; + }; +# 250 "/usr/include/c++/13/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&) =3D default; + + + + _Tuple_impl& operator=3D(const _Tuple_impl&) =3D delete; + + _Tuple_impl(_Tuple_impl&&) =3D 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))) + { } +# 338 "/usr/include/c++/13/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))) + { } +# 424 "/usr/include/c++/13/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head(*this) =3D _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) =3D 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))); + } +# 466 "/usr/include/c++/13/tuple" 3 + protected: +=20=20=20=20=20 + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + _Inherited::_M_swap(_M_tail(__in)); + } +# 485 "/usr/include/c++/13/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&) =3D default; + + + + _Tuple_impl& operator=3D(const _Tuple_impl&) =3D 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))) + { } +# 559 "/usr/include/c++/13/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head) + : _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) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, 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 __tag, 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 __tag, 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))) + { } +# 629 "/usr/include/c++/13/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) + { + _M_head(*this) =3D _Tuple_impl<_Idx, _UHead>::_M_head(__in); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) + { + _M_head(*this) + =3D std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); + } +# 663 "/usr/include/c++/13/tuple" 3 + protected: +=20=20=20=20=20 + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + } +# 680 "/usr/include/c++/13/tuple" 3 + }; + + + + template + struct _TupleConstraints + { + template + using __constructible =3D __and_...>; + + template + using __convertible =3D __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...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + template + using _TCC =3D _TupleConstraints<_Cond, _Elements...>; + + + template + using _ImplicitDefaultCtor =3D __enable_if_t< + _TCC<_Dummy>::__is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor =3D __enable_if_t< + _TCC<_Dummy>::__is_explicitly_default_constructible(), + bool>; + + + template + using _ImplicitCtor =3D __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), + bool>; + + + template + using _ExplicitCtor =3D __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), + bool>; + + template + static constexpr + __enable_if_t + __assignable() + { return __and_...>::value; } + + + template + static constexpr bool __nothrow_assignable() + { + return + __and_...>::value; + } + + + template + static constexpr bool __nothrow_constructible() + { + return + __and_...>::value; + } + + + template + static constexpr bool __valid_args() + { + return sizeof...(_Elements) =3D=3D 1 + && !is_same>::value; + } + + + template + static constexpr bool __valid_args() + { return (sizeof...(_Tail) + 2) =3D=3D sizeof...(_Elements); } +# 821 "/usr/include/c++/13/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; } +# 856 "/usr/include/c++/13/tuple" 3 + public: + template::value> =3D true> + constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template::value> =3D false> + explicit constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template=3D 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> =3D true> + constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template=3D 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> =3D false> + explicit constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> =3D true> + constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + template(), + _ExplicitCtor<_Valid, _UElements...> =3D false> + explicit constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) =3D default; + + constexpr tuple(tuple&&) =3D default; + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> =3D true> + constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> =3D false> + explicit constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> =3D true> + constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> =3D false> + explicit constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } +# 968 "/usr/include/c++/13/tuple" 3 + template::value> =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template= =3D 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template= =3D 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> =3D false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template(), + _ExplicitCtor<_Valid, _UElements...> =3D 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&...> =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> =3D false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> =3D 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...> =3D false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } +# 1092 "/usr/include/c++/13/tuple" 3 +=20=20=20=20=20 + tuple& + operator=3D(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + +=20=20=20=20=20 + tuple& + operator=3D(__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=3D(const tuple<_UElements...>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_UElements...>(), tuple&> + operator=3D(tuple<_UElements...>&& __in) + noexcept(__nothrow_assignable<_UElements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1173 "/usr/include/c++/13/tuple" 3 +=20=20=20=20=20 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) + { _Inherited::_M_swap(__in); } +# 1192 "/usr/include/c++/13/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: +=20=20=20=20=20 + void swap(tuple&) noexcept { } + + + + + + tuple() =3D 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 =3D __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor =3D __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_explicitly_default_constructible(), + bool>; + + template + using _TCC =3D _TupleConstraints<_Dummy, _T1, _T2>; + + + template + using _ImplicitCtor =3D __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), + bool>; + + + template + using _ExplicitCtor =3D __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; } +# 1306 "/usr/include/c++/13/tuple" 3 + public: + template =3D true> + constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template =3D false> + explicit constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template =3D true> + constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template =3D false> + explicit constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template(), _U1, _U2> =3D true> + constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + template(), _U1, _U2> =3D 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&) =3D default; + + constexpr tuple(tuple&&) =3D default; + + template =3D true> + constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template =3D false> + explicit constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template =3D true> + constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template =3D false> + explicit constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } +# 1399 "/usr/include/c++/13/tuple" 3 + template =3D true> + constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template =3D false> + explicit constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template =3D true> + constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template =3D false> + explicit constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1450 "/usr/include/c++/13/tuple" 3 + template::value, _T1, _T2> =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template =3D false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template =3D 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 =3D 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 =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template =3D false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template =3D 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 =3D 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)) + { } +# 1553 "/usr/include/c++/13/tuple" 3 + template =3D true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template =3D false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template =3D 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 =3D 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)) { } +# 1603 "/usr/include/c++/13/tuple" 3 +=20=20=20=20=20 + tuple& + operator=3D(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + +=20=20=20=20=20 + tuple& + operator=3D(__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=3D(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=3D(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1683 "/usr/include/c++/13/tuple" 3 + template + + __enable_if_t<__assignable(), tuple&> + operator=3D(const pair<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_head(*this) =3D __in.first; + this->_M_tail(*this)._M_head(*this) =3D __in.second; + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=3D(pair<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_head(*this) =3D std::forward<_U1>(__in.first); + this->_M_tail(*this)._M_head(*this) =3D std::forward<_U2>(__in.second); + return *this; + } +# 1729 "/usr/include/c++/13/tuple" 3 +=20=20=20=20=20 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { _Inherited::_M_swap(__in); } +# 1744 "/usr/include/c++/13/tuple" 3 + }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + inline constexpr size_t tuple_size_v> + =3D sizeof...(_Types); + + template + inline constexpr size_t tuple_size_v> + =3D sizeof...(_Types); + + + + template + struct tuple_element<__i, tuple<_Types...>> + { + static_assert(__i < sizeof...(_Types), "tuple index must be in range= "); + + using type =3D 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 >=3D sizeof...(_Types))> + __get_helper(const tuple<_Types...>&) =3D 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 >=3D sizeof...(_Elements))> + get(const tuple<_Elements...>&) =3D delete; + + + + + + + + template + constexpr _Tp& + get(tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx =3D __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 =3D __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 =3D __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 =3D __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)); + } + + + + template + struct __tuple_compare + { + static constexpr bool + __eq(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) =3D=3D 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 + constexpr bool + operator=3D=3D(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) =3D=3D sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare =3D __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__eq(__t, __u); + } +# 1945 "/usr/include/c++/13/tuple" 3 + template + constexpr bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) =3D=3D sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare =3D __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__less(__t, __u); + } + + template + constexpr bool + operator!=3D(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t =3D=3D __u); } + + template + constexpr bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template + constexpr bool + operator<=3D(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template + constexpr bool + operator>=3D(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 array; + + 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; + + + 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 +=20=20=20 + 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); } +# 2184 "/usr/include/c++/13/tuple" 3 + template +=20=20=20 + typename enable_if...>::value>::type + swap(tuple<_Elements...>&, tuple<_Elements...>&) =3D delete; + + + + + + + struct _Swallow_assign + { + template + constexpr const _Swallow_assign& + operator=3D(const _Tp&) const + { return *this; } + }; +# 2219 "/usr/include/c++/13/tuple" 3 + inline constexpr _Swallow_assign ignore{}; + + + template + struct uses_allocator, _Alloc> : true_type { }; +# 2234 "/usr/include/c++/13/tuple" 3 + template + template +=20=20=20=20=20 + 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 _Tup= le> + inline constexpr bool __unpack_std_tuple =3D false; + + template class _Trait, typename _Tp, typename... _= Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> + =3D _Trait<_Tp, _Up...>::value; + + template class _Trait, typename _Tp, typename... _= Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> + =3D _Trait<_Tp, _Up&...>::value; + + template class _Trait, typename _Tp, typename... _= Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up.= ..>> + =3D _Trait<_Tp, const _Up...>::value; + + template class _Trait, typename _Tp, typename... _= Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up.= ..>&> + =3D _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 + =3D 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 =3D tuple_size_v>; + + if constexpr (__n =3D=3D 1) + { + using _Elt =3D 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>{}); + } +# 2344 "/usr/include/c++/13/tuple" 3 + +} +# 37 "/usr/include/c++/13/bits/unique_ptr.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_function.h" 1 3 +# 63 "/usr/include/c++/13/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 116 "/usr/include/c++/13/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++/13/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; + }; +# 349 "/usr/include/c++/13/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 =3D=3D __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x !=3D __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 >=3D __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <=3D __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 >=3D __y; + + return (long unsigned int)__x >=3D (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 <=3D __y; + + return (long unsigned int)__x <=3D (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) =3D=3D std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) =3D=3D std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) =3D=3D 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) !=3D std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) !=3D std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) !=3D 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 =3D __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 =3D __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) >=3D std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >=3D 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) >=3D 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>=3D(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>=3D(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp =3D __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) <=3D std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <=3D 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) <=3D 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<=3D(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<=3D(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp =3D __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; +# 781 "/usr/include/c++/13/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" +# 1023 "/usr/include/c++/13/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); } +# 1104 "/usr/include/c++/13/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; } + }; +# 1231 "/usr/include/c++/13/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 + =3D typename __has_is_transparent<_Func, _SfinaeType>::type; + + + +} + + +# 1 "/usr/include/c++/13/backward/binders.h" 1 3 +# 60 "/usr/include/c++/13/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 107 "/usr/include/c++/13/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) con= st + { 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 +# 1439 "/usr/include/c++/13/bits/stl_function.h" 2 3 +# 38 "/usr/include/c++/13/bits/unique_ptr.h" 2 3 +# 1 "/usr/include/c++/13/bits/functional_hash.h" 1 3 +# 33 "/usr/include/c++/13/bits/functional_hash.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/functional_hash.h" 3 + + +# 1 "/usr/include/c++/13/bits/hash_bytes.h" 1 3 +# 33 "/usr/include/c++/13/bits/hash_bytes.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/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); + + +} +# 37 "/usr/include/c++/13/bits/functional_hash.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/13/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type [[__deprecated__]]; + typedef _Arg argument_type [[__deprecated__]]; + }; + + + template + struct hash; + + template + struct __poison_hash + { + static constexpr bool __enable_hash_call =3D false; + private: + + __poison_hash(__poison_hash&&); + ~__poison_hash(); + }; + + template + struct __poison_hash<_Tp, __void_t()(declval<_Tp>()= ))>> + { + static constexpr bool __enable_hash_call =3D true; + }; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type =3D typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 125 "/usr/include/c++/13/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(__va= l); } }; + + + template<> struct hash : public __hash_base { size_t o= perator()(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<= size_t>(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { retu= rn static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return sta= tic_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 noe= xcept { 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 noexce= pt { return static_cast(__val); } }; +# 201 "/usr/include/c++/13/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed =3D 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 =3D 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 !=3D 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val !=3D 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; } + }; +# 294 "/usr/include/c++/13/bits/functional_hash.h" 3 + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 39 "/usr/include/c++/13/bits/unique_ptr.h" 2 3 +# 53 "/usr/include/c++/13/bits/unique_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + +=20 +# 63 "/usr/include/c++/13/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 =3D default; + + + + + + + template>> + + default_delete(const default_delete<_Up>&) noexcept { } + + +=20=20=20=20=20 + 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; + } + }; +# 111 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template + struct default_delete<_Tp[]> + { + public: + + constexpr default_delete() noexcept =3D default; +# 127 "/usr/include/c++/13/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 =3D _Up*; + }; + + template + struct + _Ptr<_Up, _Ep, __void_t::type::pointer>> + { + using type =3D typename remove_reference<_Ep>::type::pointer; + }; + + public: + using _DeleterConstraint =3D enable_if< + __and_<__not_>, + is_default_constructible<_Dp>>::value>; + + using pointer =3D 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() =3D default; +=20=20=20=20=20 + __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() =3D __p; } + + template + + __uniq_ptr_impl(pointer __p, _Del&& __d) + : _M_t(__p, std::forward<_Del>(__d)) { } + +=20=20=20=20=20 + __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept + : _M_t(std::move(__u._M_t)) + { __u._M_ptr() =3D nullptr; } + +=20=20=20=20=20 + __uniq_ptr_impl& operator=3D(__uniq_ptr_impl&& __u) noexcept + { + reset(__u.release()); + _M_deleter() =3D std::forward<_Dp>(__u._M_deleter()); + return *this; + } + +=20=20=20=20=20 + pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } +=20=20=20=20=20 + pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } +=20=20=20=20=20 + _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } +=20=20=20=20=20 + const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } + +=20=20=20=20=20 + void reset(pointer __p) noexcept + { + const pointer __old_p =3D _M_ptr(); + _M_ptr() =3D __p; + if (__old_p) + _M_deleter()(__old_p); + } + +=20=20=20=20=20 + pointer release() noexcept + { + pointer __p =3D _M_ptr(); + _M_ptr() =3D nullptr; + return __p; + } + +=20=20=20=20=20 + 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 =3D 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&&) =3D default; + __uniq_ptr_data& operator=3D(__uniq_ptr_data&&) =3D 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&&) =3D default; + __uniq_ptr_data& operator=3D(__uniq_ptr_data&&) =3D 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&&) =3D delete; + __uniq_ptr_data& operator=3D(__uniq_ptr_data&&) =3D 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&&) =3D delete; + __uniq_ptr_data& operator=3D(__uniq_ptr_data&&) =3D delete; + }; + + + + + + + + template > + class unique_ptr + { + template + using _DeleterConstraint =3D + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + public: + using pointer =3D typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type =3D _Tp; + using deleter_type =3D _Dp; + + private: + + + template + using __safe_conversion_up =3D __and_< + is_convertible::pointer, pointer>, + __not_> + >; + + public: + + + + template> + constexpr unique_ptr() noexcept + : _M_t() + { } + + + + + + + + template> + + explicit + unique_ptr(pointer __p) noexcept + : _M_t(__p) + { } +# 328 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template>> + + unique_ptr(pointer __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 341 "/usr/include/c++/13/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&&>) =3D delete; + + + template> + constexpr unique_ptr(nullptr_t) noexcept + : _M_t() + { } + + + + + unique_ptr(unique_ptr&&) =3D 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 =3D _M_t._M_ptr(); + if (__ptr !=3D nullptr) + get_deleter()(std::move(__ptr)); + __ptr =3D pointer(); + } + + + + + + + + unique_ptr& operator=3D(unique_ptr&&) =3D default; +# 423 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template + + typename enable_if< __and_< + __safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=3D(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() =3D std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + +=20=20=20=20=20 + unique_ptr& + operator=3D(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + +=20=20=20=20=20 + typename add_lvalue_reference::type + operator*() const noexcept(noexcept(*std::declval())) + { + do { if (std::__is_constant_evaluated() && !bool(get() !=3D pointer())) _= _builtin_unreachable(); } while (false); + return *get(); + } + + +=20=20=20=20=20 + pointer + operator->() const noexcept + { + ; + return get(); + } + + +=20=20=20=20=20 + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + +=20=20=20=20=20 + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + +=20=20=20=20=20 + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + +=20=20=20=20=20 + explicit operator bool() const noexcept + { return get() =3D=3D pointer() ? false : true; } + + + + +=20=20=20=20=20 + pointer + release() noexcept + { return _M_t.release(); } + + + + + + + +=20=20=20=20=20 + void + reset(pointer __p =3D pointer()) noexcept + { + static_assert(__is_invocable::value, + "unique_ptr's deleter must be invocable with a pointer"); + _M_t.reset(std::move(__p)); + } + + +=20=20=20=20=20 + 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&) =3D delete; + unique_ptr& operator=3D(const unique_ptr&) =3D delete; + }; +# 534 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template + class unique_ptr<_Tp[], _Dp> + { + template + using _DeleterConstraint =3D + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + + template + using __is_derived_Tp + =3D __and_< is_base_of<_Tp, _Up>, + __not_, __remove_cv_t<_Up>>> >; + + public: + using pointer =3D typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type =3D _Tp; + using deleter_type =3D _Dp; + + + + template, + typename _UP_pointer =3D typename _UPtr::pointer, + typename _UP_element_type =3D typename _UPtr::element_type> + using __safe_conversion_up =3D __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 =3D __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() + { } +# 596 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template, + typename =3D typename enable_if< + __safe_conversion_raw<_Up>::value, bool>::type> + + explicit + unique_ptr(_Up __p) noexcept + : _M_t(__p) + { } +# 615 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template, + is_copy_constructible<_Del>>> + + unique_ptr(_Up __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 630 "/usr/include/c++/13/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 =3D _Require<__safe_conversion_raw<_Up>>> + unique_ptr(_Up, + __enable_if_t::value, + _DelUnref&&>) =3D delete; + + + unique_ptr(unique_ptr&&) =3D 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 =3D _M_t._M_ptr(); + if (__ptr !=3D nullptr) + get_deleter()(__ptr); + __ptr =3D pointer(); + } + + + + + + + + unique_ptr& + operator=3D(unique_ptr&&) =3D default; +# 694 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template + + typename + enable_if<__and_<__safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=3D(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() =3D std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + +=20=20=20=20=20 + unique_ptr& + operator=3D(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + +=20=20=20=20=20 + typename std::add_lvalue_reference::type + operator[](size_t __i) const + { + do { if (std::__is_constant_evaluated() && !bool(get() !=3D pointer())) _= _builtin_unreachable(); } while (false); + return get()[__i]; + } + + +=20=20=20=20=20 + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + +=20=20=20=20=20 + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + +=20=20=20=20=20 + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + +=20=20=20=20=20 + explicit operator bool() const noexcept + { return get() =3D=3D pointer() ? false : true; } + + + + +=20=20=20=20=20 + pointer + release() noexcept + { return _M_t.release(); } + + + + + + + + template , + __and_, + is_pointer<_Up>, + is_convertible< + typename remove_pointer<_Up>::type(*)[], + element_type(*)[] + > + > + > + >> +=20=20=20=20=20 + void + reset(_Up __p) noexcept + { _M_t.reset(std::move(__p)); } + +=20=20=20=20=20 + void reset(nullptr_t =3D nullptr) noexcept + { reset(pointer()); } + + +=20=20=20=20=20 + 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&) =3D delete; + unique_ptr& operator=3D(const unique_ptr&) =3D delete; + }; + + + + + + template + inline + + +=20=20=20 + 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>&) =3D delete; + + + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() =3D=3D __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return !__x; } + + + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return !__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=3D(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() !=3D __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator!=3D(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return (bool)__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=3D(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<=3D(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=3D(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(nullptr < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=3D(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>=3D(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__x < __y); } + + + template + [[__nodiscard__]] + inline bool + operator>=3D(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(__x < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=3D(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(nullptr < __x); } +# 1006 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template::__enable_hash_call> + struct __uniq_ptr_hash + + : private __poison_hash<_Ptr> + + { + size_t + operator()(const _Up& __u) const + noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) + { return hash<_Ptr>()(__u.get()); } + }; + + template + struct __uniq_ptr_hash<_Up, _Ptr, false> + : private __poison_hash<_Ptr> + { }; + + + + template + struct hash> + : public __hash_base>, + public __uniq_ptr_hash> + { }; + + + + + +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 =3D typename _MakeUniq<_Tp>::__single_object; + template + using __unique_ptr_array_t =3D typename _MakeUniq<_Tp>::__array; + template + using __invalid_make_unique_t =3D typename _MakeUniq<_Tp>::__invalid_t= ype; +} +# 1066 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template +=20=20=20 + inline __detail::__unique_ptr_t<_Tp> + make_unique(_Args&&... __args) + { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } +# 1081 "/usr/include/c++/13/bits/unique_ptr.h" 3 + template +=20=20=20 + 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&&...) =3D delete; +# 1154 "/usr/include/c++/13/bits/unique_ptr.h" 3 + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 79 "/usr/include/c++/13/memory" 2 3 + +# 1 "/usr/include/c++/13/bits/shared_ptr.h" 1 3 +# 52 "/usr/include/c++/13/bits/shared_ptr.h" 3 +# 1 "/usr/include/c++/13/iosfwd" 1 3 +# 36 "/usr/include/c++/13/iosfwd" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/iosfwd" 3 + +# 1 "/usr/include/c++/13/bits/requires_hosted.h" 1 3 +# 39 "/usr/include/c++/13/iosfwd" 2 3 + + +# 1 "/usr/include/c++/13/bits/stringfwd.h" 1 3 +# 37 "/usr/include/c++/13/bits/stringfwd.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/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 =3D allocator<_CharT> > + class basic_string; + +} + + + typedef basic_string string; + + + typedef basic_string wstring; +# 89 "/usr/include/c++/13/bits/stringfwd.h" 3 + typedef basic_string u16string; + + + typedef basic_string u32string; + + + + + +} +# 42 "/usr/include/c++/13/iosfwd" 2 3 +# 1 "/usr/include/c++/13/bits/postypes.h" 1 3 +# 38 "/usr/include/c++/13/bits/postypes.h" 3 +=20=20=20=20=20=20=20 +# 39 "/usr/include/c++/13/bits/postypes.h" 3 + +# 1 "/usr/include/c++/13/cwchar" 1 3 +# 39 "/usr/include/c++/13/cwchar" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/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/13/include/stddef.h" 1 3 4 +# 36 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 39 "/usr/include/wchar.h" 2 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; +# 42 "/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; +# 43 "/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; +# 44 "/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; +# 47 "/usr/include/wchar.h" 2 3 4 +# 79 "/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 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 (tr= ue); + + + +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__)); +# 182 "/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__)); +# 241 "/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 >=3D '\0' && __c <=3D '\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 >=3D L'\0' && __wc <=3D L'\x= 7f' + ? (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 !=3D __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); +# 397 "/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); +# 429 "/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_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 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); +# 512 "/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); +# 552 "/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); +# 581 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noe= xcept (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) ; +# 657 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict= __format, ...) __asm__ ("" "__isoc99_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "_= _isoc99_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restri= ct __format, ...) noexcept (true) __asm__ ("" "__isoc99_swscanf") + + + ; +# 688 "/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) ; + + + + + + + +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __f= ormat, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __a= rg) __asm__ ("" "__isoc99_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restr= ict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_v= swscanf") + + + ; +# 744 "/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); +# 799 "/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); +# 825 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 835 "/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 *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, + size_t __n, size_t __ns1) noexcept (true); + + + + +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 *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n, + size_t __ns) noexcept (true); +extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n) noexcept (true); +extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __destlen) noexcept (true); +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 *__wcpncpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n, + size_t __destlen) noexcept (true); +extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __destlen) noexcept (true); +extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n, size_t __destlen) noexcept (true); +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 __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 __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_unlocked_chk (wchar_t *__restrict __s, size_t __s= ize, + int __n, __FILE *__restrict __stream) + __attribute__ ((__warn_unused_result__)); + + + +extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar, + mbstate_t *__restrict __p, + size_t __buflen) noexcept (true) __attribute__ ((__warn_unused_res= ult__)); +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 __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 __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 __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); +# 869 "/usr/include/wchar.h" 2 3 4 +# 879 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 3 4 +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 s= ize of destination " "buffer"))) + ; + +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_object_size (__s1, 0)) && (__b= uiltin_object_size (__s1, 0)) =3D=3D (long unsigned int) -1) || (((__typeof= (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0= )) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D ((__builtin_o= bject_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (_= _n)) <=3D ((__builtin_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)) <=3D (__builtin_object_size (__s1, 0)) / (size= of (wchar_t)))) && !(((long unsigned int) (__n)) <=3D (__builtin_object_siz= e (__s1, 0)) / (sizeof (wchar_t)))) ? __wmemcpy_chk_warn (__s1, __s2, __n, = (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmemcpy_chk (__= s1, __s2, __n, (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))))) + + ; +} + + +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, s= ize_t __n, size_t __ns1) noexcept (true) __asm__ ("" "__wmemmove_chk") + + + __attribute__((__warning__ ("wmemmove called with length bigger than = size of destination " "buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) wchar_t * +__attribute__ ((__leaf__)) wmemmove (wchar_t *__s1, const wchar_t *__s2, s= ize_t __n) noexcept (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__s1, 0)) && (__b= uiltin_object_size (__s1, 0)) =3D=3D (long unsigned int) -1) || (((__typeof= (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0= )) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D ((__builtin_o= bject_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (_= _n)) <=3D ((__builtin_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)) <=3D (__builtin_object_size (__s1, 0)) / (siz= eof (wchar_t)))) && !(((long unsigned int) (__n)) <=3D (__builtin_object_si= ze (__s1, 0)) / (sizeof (wchar_t)))) ? __wmemmove_chk_warn (__s1, __s2, __n= , (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmemmove_chk = (__s1, __s2, __n, (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))))) + + ; +} + + + +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 __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_object_size (__s1, 0)) && (__b= uiltin_object_size (__s1, 0)) =3D=3D (long unsigned int) -1) || (((__typeof= (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0= )) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D ((__builtin_o= bject_size (__s1, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (_= _n)) <=3D ((__builtin_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)) <=3D (__builtin_object_size (__s1, 0)) / (siz= eof (wchar_t)))) && !(((long unsigned int) (__n)) <=3D (__builtin_object_si= ze (__s1, 0)) / (sizeof (wchar_t)))) ? __wmempcpy_chk_warn (__s1, __s2, __n= , (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))) : __wmempcpy_chk = (__s1, __s2, __n, (__builtin_object_size (__s1, 0)) / (sizeof (wchar_t))))) + + ; +} + + + +extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) no= except (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 s= ize of destination " "buffer"))) + ; + +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_object_size (__s, 0)) && (__bu= iltin_object_size (__s, 0)) =3D=3D (long unsigned int) -1) || (((__typeof (= __n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) && (__n) > 0))= && __builtin_constant_p ((((long unsigned int) (__n)) <=3D ((__builtin_obj= ect_size (__s, 0))) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)= ) <=3D ((__builtin_object_size (__s, 0))) / ((sizeof (wchar_t)))))) ? __wme= mset_alias (__s, __c, __n) : ((((__typeof (__n)) 0 < (__typeof (__n)) -1 ||= (__builtin_constant_p (__n) && (__n) > 0)) && __builtin_constant_p ((((lon= g unsigned int) (__n)) <=3D (__builtin_object_size (__s, 0)) / (sizeof (wch= ar_t)))) && !(((long unsigned int) (__n)) <=3D (__builtin_object_size (__s,= 0)) / (sizeof (wchar_t)))) ? __wmemset_chk_warn (__s, __c, __n, (__builtin= _object_size (__s, 0)) / (sizeof (wchar_t))) : __wmemset_chk (__s, __c, __n= , (__builtin_object_size (__s, 0)) / (sizeof (wchar_t))))) + + ; +} + + +extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, const wchar_t = *__restrict __src) noexcept (true) __asm__ ("" "wcscpy") + + ; + +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 =3D __builtin_object_size (__dest, 2 > 1); + if (sz !=3D (size_t) -1) + return __wcscpy_chk (__dest, __src, sz / sizeof (wchar_t)); + return __wcscpy_alias (__dest, __src); +} + + +extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, const wchar_t = *__restrict __src) noexcept (true) __asm__ ("" "wcpcpy") + + ; + +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 =3D __builtin_object_size (__dest, 2 > 1); + if (sz !=3D (size_t) -1) + return __wcpcpy_chk (__dest, __src, sz / sizeof (wchar_t)); + return __wcpcpy_alias (__dest, __src); +} + + +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 wcha= r_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true) __asm_= _ ("" "__wcsncpy_chk") + + + + __attribute__((__warning__ ("wcsncpy called with length bigger than s= ize of destination " "buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) wchar_t * +__attribute__ ((__leaf__)) wcsncpy (wchar_t *__restrict __dest, const wcha= r_t *__restrict __src, size_t __n) noexcept (true) + +{ + return (((__builtin_constant_p (__builtin_object_size (__dest, 2 > 1)) &= & (__builtin_object_size (__dest, 2 > 1)) =3D=3D (long unsigned int) -1) ||= (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) = && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D (= (__builtin_object_size (__dest, 2 > 1))) / ((sizeof (wchar_t))))) && (((lon= g unsigned int) (__n)) <=3D ((__builtin_object_size (__dest, 2 > 1))) / ((s= izeof (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)) <=3D (__builtin_obj= ect_size (__dest, 2 > 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) = (__n)) <=3D (__builtin_object_size (__dest, 2 > 1)) / (sizeof (wchar_t)))) = ? __wcsncpy_chk_warn (__dest, __src, __n, (__builtin_object_size (__dest, 2= > 1)) / (sizeof (wchar_t))) : __wcsncpy_chk (__dest, __src, __n, (__builti= n_object_size (__dest, 2 > 1)) / (sizeof (wchar_t))))) + + ; +} + + +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 wcha= r_t *__restrict __src, size_t __n, size_t __destlen) noexcept (true) __asm_= _ ("" "__wcpncpy_chk") + + + + __attribute__((__warning__ ("wcpncpy called with length bigger than s= ize of destination " "buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) wchar_t * +__attribute__ ((__leaf__)) wcpncpy (wchar_t *__restrict __dest, const wcha= r_t *__restrict __src, size_t __n) noexcept (true) + +{ + return (((__builtin_constant_p (__builtin_object_size (__dest, 2 > 1)) &= & (__builtin_object_size (__dest, 2 > 1)) =3D=3D (long unsigned int) -1) ||= (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n) = && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D (= (__builtin_object_size (__dest, 2 > 1))) / ((sizeof (wchar_t))))) && (((lon= g unsigned int) (__n)) <=3D ((__builtin_object_size (__dest, 2 > 1))) / ((s= izeof (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)) <=3D (__builtin_obj= ect_size (__dest, 2 > 1)) / (sizeof (wchar_t)))) && !(((long unsigned int) = (__n)) <=3D (__builtin_object_size (__dest, 2 > 1)) / (sizeof (wchar_t)))) = ? __wcpncpy_chk_warn (__dest, __src, __n, (__builtin_object_size (__dest, 2= > 1)) / (sizeof (wchar_t))) : __wcpncpy_chk (__dest, __src, __n, (__builti= n_object_size (__dest, 2 > 1)) / (sizeof (wchar_t))))) + + ; +} + + +extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, const wchar_t = *__restrict __src) noexcept (true) __asm__ ("" "wcscat") + + ; + +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 =3D __builtin_object_size (__dest, 2 > 1); + if (sz !=3D (size_t) -1) + return __wcscat_chk (__dest, __src, sz / sizeof (wchar_t)); + return __wcscat_alias (__dest, __src); +} + + +extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, const wchar_t= *__restrict __src, size_t __n) noexcept (true) __asm__ ("" "wcsncat") + + + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) wchar_t * +__attribute__ ((__leaf__)) wcsncat (wchar_t *__restrict __dest, const wcha= r_t *__restrict __src, size_t __n) noexcept (true) + +{ + size_t sz =3D __builtin_object_size (__dest, 2 > 1); + if (sz !=3D (size_t) -1) + return __wcsncat_chk (__dest, __src, __n, sz / sizeof (wchar_t)); + return __wcsncat_alias (__dest, __src, __n); +} + + + +extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, const wc= har_t *__restrict __fmt, ...) noexcept (true) __asm__ ("" "swprintf") + + + ; + + +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 =3D __builtin_object_size (__s, 2 > 1); + if (sz !=3D (size_t) -1 || 2 > 1) + return __swprintf_chk (__s, __n, 2 - 1, + sz / sizeof (wchar_t), __fmt, __builtin_va_arg_pack ()); + return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ()); +} +# 230 "/usr/include/riscv64-linux-gnu/bits/wchar2.h" 3 4 +extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, const w= char_t *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) __asm__ ("" = "vswprintf") + + + ; + +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 =3D __builtin_object_size (__s, 2 > 1); + if (sz !=3D (size_t) -1 || 2 > 1) + return __vswprintf_chk (__s, __n, 2 - 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 (2 - 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, 2 - 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 (2 - 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, 2 - 1, __fmt, __ap); +} + + + +extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *= __restrict __stream) __asm__ ("" "fgetws") + + __attribute__ ((__warn_unuse= d_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 __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) wchar_t * +fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) +{ + size_t sz =3D __builtin_object_size (__s, 2 > 1); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <=3D ((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)) = <=3D (sz) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <=3D (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 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_unloc= ked_chk") + + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "fgetws_unlocked called with bigger size than length " "of destination buff= er"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) wchar_t * +fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __st= ream) +{ + size_t sz =3D __builtin_object_size (__s, 2 > 1); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((sizeof (wchar_t))))) && (((long unsigned int) (__n)) <=3D ((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)) = <=3D (sz) / (sizeof (wchar_t)))) && !(((long unsigned int) (__n)) <=3D (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 size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbst= ate_t *__restrict __ps) noexcept (true) __asm__ ("" "wcrtomb") + + __attribute__ ((__warn_unu= sed_result__)); + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) size_t +__attribute__ ((__leaf__)) wcrtomb (char *__restrict __s, wchar_t __wchar,= mbstate_t *__restrict __ps) noexcept (true) + +{ + + + + + + + + if (__builtin_object_size (__s, 2 > 1) !=3D (size_t) -1 + && 16 > __builtin_object_size (__s, 2 > 1)) + return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, = 2 > 1)); + return __wcrtomb_alias (__s, __wchar, __ps); +} + + +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 __dstl= en) noexcept (true) __asm__ ("" "__mbsrtowcs_chk") + + + + + __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller= than len " "* sizeof (wchar_t)"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) size_t +__attribute__ ((__leaf__)) mbsrtowcs (wchar_t *__restrict __dst, const cha= r **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (t= rue) + +{ + return (((__builtin_constant_p (__builtin_object_size (__dst, 2 > 1)) &&= (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (wchar_t))))) &&= (((long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > 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)) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (wchar_t)))) = && !(((long unsigned int) (__len)) <=3D (__builtin_object_size (__dst, 2 > = 1)) / (sizeof (wchar_t)))) ? __mbsrtowcs_chk_warn (__dst, __src, __len, __p= s, (__builtin_object_size (__dst, 2 > 1)) / (sizeof (wchar_t))) : __mbsrtow= cs_chk (__dst, __src, __len, __ps, (__builtin_object_size (__dst, 2 > 1)) /= (sizeof (wchar_t))))) + + ; +} + + +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 __dstl= en) noexcept (true) __asm__ ("" "__wcsrtombs_chk") + + + + + __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller = than len"))); + +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 (t= rue) + +{ + return (((__builtin_constant_p (__builtin_object_size (__dst, 2 > 1)) &&= (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > 1))) = / ((sizeof (char)))))) ? __wcsrtombs_alias (__dst, __src, __len, __ps) : ((= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (char)))) && !(((lo= ng unsigned int) (__len)) <=3D (__builtin_object_size (__dst, 2 > 1)) / (si= zeof (char)))) ? __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin= _object_size (__dst, 2 > 1)) : __wcsrtombs_chk (__dst, __src, __len, __ps, = __builtin_object_size (__dst, 2 > 1)))) + + ; +} + + + +extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, const char **= __restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) n= oexcept (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 smalle= r than len " "* sizeof (wchar_t)"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) size_t +__attribute__ ((__leaf__)) mbsnrtowcs (wchar_t *__restrict __dst, const ch= ar **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __= ps) noexcept (true) + +{ + return (((__builtin_constant_p (__builtin_object_size (__dst, 2 > 1)) &&= (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (wchar_t))))) &&= (((long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > 1)= )) / ((sizeof (wchar_t)))))) ? __mbsnrtowcs_alias (__dst, __src, __nmc, __l= en, __ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_c= onstant_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigne= d int) (__len)) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (wcha= r_t)))) && !(((long unsigned int) (__len)) <=3D (__builtin_object_size (__d= st, 2 > 1)) / (sizeof (wchar_t)))) ? __mbsnrtowcs_chk_warn (__dst, __src, _= _nmc, __len, __ps, (__builtin_object_size (__dst, 2 > 1)) / (sizeof (wchar_= t))) : __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, (__builtin_objec= t_size (__dst, 2 > 1)) / (sizeof (wchar_t))))) + + ; +} + + +extern size_t __wcsnrtombs_alias (char *__restrict __dst, const wchar_t **= __restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) n= oexcept (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 smalle= r than len"))); + +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_object_size (__dst, 2 > 1)) &&= (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > 1))) = / ((sizeof (char)))))) ? __wcsnrtombs_alias (__dst, __src, __nwc, __len, __= ps) : ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constan= t_p (__len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int)= (__len)) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (char)))) &= & !(((long unsigned int) (__len)) <=3D (__builtin_object_size (__dst, 2 > 1= )) / (sizeof (char)))) ? __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len,= __ps, __builtin_object_size (__dst, 2 > 1)) : __wcsnrtombs_chk (__dst, __s= rc, __nwc, __len, __ps, __builtin_object_size (__dst, 2 > 1)))) + + ; +} +# 880 "/usr/include/wchar.h" 2 3 4 + + +} +# 45 "/usr/include/c++/13/cwchar" 2 3 +# 62 "/usr/include/c++/13/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/include/c++/13/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; +# 234 "/usr/include/c++/13/cwchar" 3 + +} +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 260 "/usr/include/c++/13/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 280 "/usr/include/c++/13/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; + +} +# 41 "/usr/include/c++/13/bits/postypes.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 62 "/usr/include/c++/13/bits/postypes.h" 3 + typedef long int streamoff; + + + + + + typedef ptrdiff_t streamsize; +# 81 "/usr/include/c++/13/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 103 "/usr/include/c++/13/bits/postypes.h" 3 + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + + fpos(const fpos&) =3D default; + fpos& operator=3D(const fpos&) =3D default; + ~fpos() =3D default; + + + + operator streamoff() const { return _M_off; } + + + void + state(_StateT __st) + { _M_state =3D __st; } + + + _StateT + state() const + { return _M_state; } + + + + + + fpos& + operator+=3D(streamoff __off) + { + _M_off +=3D __off; + return *this; + } + + + + + + fpos& + operator-=3D(streamoff __off) + { + _M_off -=3D __off; + return *this; + } + + + + + + + + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos +=3D __off; + return __pos; + } + + + + + + + + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -=3D __off; + return __pos; + } + + + + + + + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + + + + + + template + inline bool + operator=3D=3D(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) =3D=3D streamoff(__rhs); } + + template + inline bool + operator!=3D(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) !=3D streamoff(__rhs); } + + + + + + typedef fpos streampos; + + typedef fpos wstreampos; +# 215 "/usr/include/c++/13/bits/postypes.h" 3 + typedef fpos u16streampos; + + typedef fpos u32streampos; + + + +} +# 43 "/usr/include/c++/13/iosfwd" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 76 "/usr/include/c++/13/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 =3D allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc =3D allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc =3D allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc =3D 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; +# 255 "/usr/include/c++/13/iosfwd" 3 + +} +# 53 "/usr/include/c++/13/bits/shared_ptr.h" 2 3 +# 1 "/usr/include/c++/13/bits/shared_ptr_base.h" 1 3 +# 52 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 +# 1 "/usr/include/c++/13/typeinfo" 1 3 +# 32 "/usr/include/c++/13/typeinfo" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/typeinfo" 3 + + + + + + +#pragma GCC visibility push(default) + + + + + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 84 "/usr/include/c++/13/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] =3D=3D '*' ? __name + 1 : __name; } + + + + bool before(const type_info& __arg) const noexcept; + +=20=20=20 + bool operator=3D=3D(const type_info& __arg) const noexcept; + + + bool operator!=3D(const type_info& __arg) const noexcept + { return !operator=3D=3D(__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=3D(const type_info&) =3D delete; + type_info(const type_info&) =3D delete; +# 167 "/usr/include/c++/13/typeinfo" 3 + }; + + + inline bool + type_info::before(const type_info& __arg) const noexcept + { + + + + + if (__name[0] !=3D '*' || __arg.__name[0] !=3D '*') + return __builtin_strcmp (__name, __arg.__name) < 0; +# 187 "/usr/include/c++/13/typeinfo" 3 + return __name < __arg.__name; + } + + + + inline bool + type_info::operator=3D=3D(const type_info& __arg) const noexcept + { + if (std::__is_constant_evaluated()) + return this =3D=3D &__arg; + + if (__name =3D=3D __arg.__name) + return true; + + + + + + + return __name[0] !=3D '*' && __builtin_strcmp (__name, __arg.name()) = =3D=3D 0; + + + + } +# 220 "/usr/include/c++/13/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 +# 53 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/include/c++/13/bits/allocated_ptr.h" 1 3 +# 40 "/usr/include/c++/13/bits/allocated_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct __allocated_ptr + { + using pointer =3D typename allocator_traits<_Alloc>::pointer; + using value_type =3D 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 =3D nullptr; } + + + ~__allocated_ptr() + { + if (_M_ptr !=3D nullptr) + std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); + } + + + __allocated_ptr& + operator=3D(std::nullptr_t) noexcept + { + _M_ptr =3D nullptr; + return *this; + } + + + value_type* get() { return std::__to_address(_M_ptr); } + + private: + _Alloc* _M_alloc; + pointer _M_ptr; + }; + + + template + __allocated_ptr<_Alloc> + __allocate_guarded(_Alloc& __a) + { + return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; + } + + + +} +# 54 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 + + + +# 1 "/usr/include/c++/13/bits/refwrap.h" 1 3 +# 33 "/usr/include/c++/13/bits/refwrap.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/refwrap.h" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 52 "/usr/include/c++/13/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 =3D _Res; + using __maybe_type + =3D _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity =3D integral_constant; + }; +# 103 "/usr/include/c++/13/bits/refwrap.h" 3 +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _C= lass, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_C= lass::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes.= ..> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgType= s...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { usi= ng __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...= ) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using _= _vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatil= e > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __va= rarg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volat= ile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __= vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const vo= latile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> {= using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...= ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _= ArgTypes...> { using __vararg =3D true_type; }; +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _= Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_= Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgType= s...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTy= pes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { = using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... = ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { usi= ng __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) vol= atile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using= __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) = volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { us= ing __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) co= nst volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgType= s...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgT= ypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _= Class, _ArgTypes...> { using __vararg =3D true_type; }; +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, = _Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (= _Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTy= pes...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_Arg= Types...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...>= { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes.= .. ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> {= using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...)= volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { = using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... = ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...= > { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes.= ..) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _= ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*= )(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const vo= latile _Class, _ArgTypes...> { using __vararg =3D true_type; }; + + +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<= _Res, _Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<= _Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _C= lass, _ArgTypes...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (_Cl= ass::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Cl= ass, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Cl= ass::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const= _Class, _ArgTypes...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res (= _Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, vol= atile _Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<= _Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base= <_Res, volatile _Class, _ArgTypes...> { using __vararg =3D true_type; }; te= mplate struct _Mem_f= n_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_= traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =3D= false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatil= e noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...= > { using __vararg =3D true_type; }; +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_bas= e<_Res, _Class, _ArgTypes...> { using __vararg =3D false_type; }; template<= typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_trait= s<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res= , _Class, _ArgTypes...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Res = (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, con= st _Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Re= s (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Re= s, const _Class, _ArgTypes...> { using __vararg =3D true_type; }; template<= typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_trait= s<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base= <_Res, volatile _Class, _ArgTypes...> { using __vararg =3D false_type; }; t= emplate struct _Mem_= fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn= _traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =3D true= _type; }; template s= truct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexce= pt> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { usin= g __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...)= const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Cla= ss, _ArgTypes...> { using __vararg =3D true_type; }; +template struct _Me= m_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_ba= se<_Res, _Class, _ArgTypes...> { using __vararg =3D false_type; }; template= struct _Mem_fn_trai= ts<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_R= es, _Class, _ArgTypes...> { using __vararg =3D true_type; }; template struct _Mem_fn_traits<_Re= s (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, = const _Class, _ArgTypes...> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<= _Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base= <_Res, const _Class, _ArgTypes...> { using __vararg =3D true_type; }; templ= ate struct _Mem_fn_t= raits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits= _base<_Res, volatile _Class, _ArgTypes...> { using __vararg =3D false_type;= }; template struct = _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _= Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = =3D true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile = && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes..= .> { using __vararg =3D false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgType= s... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const vol= atile _Class, _ArgTypes...> { using __vararg =3D 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 =3D 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 =3D typename _Mem_fn_traits<_MemFunPtr>::__result_= type; + }; +#pragma GCC diagnostic pop +# 302 "/usr/include/c++/13/bits/refwrap.h" 3 + template + class reference_wrapper + + + + : public _Reference_wrapper_base_memfun::type> + + { + _Tp* _M_data; + +=20=20=20=20=20 + static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r)= ; } + + static void _S_fun(_Tp&&) =3D delete; + + template> + using __not_same + =3D typename enable_if::value>::type; + + public: + typedef _Tp type; + + + + + template, typename + =3D 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&) =3D default; + + reference_wrapper& + operator=3D(const reference_wrapper&) =3D default; + +=20=20=20=20=20 + operator _Tp&() const noexcept + { return this->get(); } + +=20=20=20=20=20 + _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)...); + } + }; + + + template + reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; + + + + + + template +=20=20=20 + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template +=20=20=20 + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) =3D delete; + + template + void cref(const _Tp&&) =3D delete; + + + template +=20=20=20 + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return __t; } + + + template +=20=20=20 + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return { __t.get() }; } + + + + +} +# 58 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 + + +# 1 "/usr/include/c++/13/ext/aligned_buffer.h" 1 3 +# 32 "/usr/include/c++/13/ext/aligned_buffer.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/aligned_buffer.h" 3 + + + + + + + +namespace __gnu_cxx +{ + + + + + template + struct __aligned_membuf + { + + + + + + struct _Tp2 { _Tp _M_t; }; + + alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp= )]; + + __aligned_membuf() =3D 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()); } + }; + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + template + struct __aligned_buffer + : std::aligned_storage + { + typename + std::aligned_storage::type _M_storage; + + __aligned_buffer() =3D 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()); } + }; +#pragma GCC diagnostic pop + + +} +# 61 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/include/c++/13/ext/atomicity.h" 1 3 +# 32 "/usr/include/c++/13/ext/atomicity.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/atomicity.h" 3 + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr.h" 1 3 +# 30 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr.h" 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 1 3 +# 35 "/usr/include/riscv64-linux-gnu/c++/13/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/13/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 + + + + + +# 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 +# 7 "/usr/include/riscv64-linux-gnu/bits/types/struct_timespec.h" 2 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 +# 80 "/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; +}; +# 81 "/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); + + +} +# 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) __attr= ibute__ ((__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 *__para= m) + noexcept (true); + + +extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noe= xcept (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) noe= xcept (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/13/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) noe= xcept (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) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/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); + + + + +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) noe= xcept (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 *__t= p) + 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) noexce= pt (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_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[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 =3D PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE =3D PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK =3D PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT =3D PTHREAD_MUTEX_NORMAL + + + + , PTHREAD_MUTEX_FAST_NP =3D PTHREAD_MUTEX_TIMED_NP + +}; + + + + +enum +{ + PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_STALLED_NP =3D PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_ROBUST, + PTHREAD_MUTEX_ROBUST_NP =3D 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 =3D 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) noe= xcept (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__ ((__con= st__)); + + +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) __at= tribute__ ((__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 __poli= cy) + 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__ ((__d= eprecated__)); + + +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 *__stackadd= r, + 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 *__na= me) + 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; +}; +# 697 "/usr/include/pthread.h" 3 4 +extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf) + ; +# 709 "/usr/include/pthread.h" 3 4 +extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf) + ; +# 732 "/usr/include/pthread.h" 3 4 +extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf) + ; +# 745 "/usr/include/pthread.h" 3 4 +extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *_= _buf) + ; + + + +extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf) + __attribute__ ((__noreturn__)) + + __attribute__ ((__weak__)) + + ; +# 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 __mut= ex, + 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 deprecat= ed, 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 __k= ind) + 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 *) n= oexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") + + __attribute__ ((__nonnull__ (1))) + __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is depre= cated, 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) noe= xcept (true) __asm__ ("" "pthread_mutexattr_setrobust") + + __attribute__ ((__nonnull__ (1))) + __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is depre= cated, 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 __rwlo= ck, + 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 __rwlo= ck, + 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 __rwlo= ck, + 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 __rwlo= ck, + 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))); +# 1332 "/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 =3D=3D __thread2; +} + + +} +# 36 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 2 3 +# 47 "/usr/include/riscv64-linux-gnu/c++/13/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; +# 102 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# 299 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 3 +static inline int +__gthread_active_p (void) +{ + return 1; +} +# 659 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 3 +static inline int +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), + void *__args) +{ + return pthread_create (__threadid, __null, __func, __args); +} + +static inline int +__gthread_join (__gthread_t __threadid, void **__value_ptr) +{ + return pthread_join (__threadid, __value_ptr); +} + +static inline int +__gthread_detach (__gthread_t __threadid) +{ + return pthread_detach (__threadid); +} + +static inline int +__gthread_equal (__gthread_t __t1, __gthread_t __t2) +{ + return pthread_equal (__t1, __t2); +} + +static inline __gthread_t +__gthread_self (void) +{ + return pthread_self (); +} + +static inline int +__gthread_yield (void) +{ + return sched_yield (); +} + +static inline int +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) +{ + if (__gthread_active_p ()) + return pthread_once (__once, __func); + else + return -1; +} + +static inline int +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) +{ + return pthread_key_create (__key, __dtor); +} + +static inline int +__gthread_key_delete (__gthread_key_t __key) +{ + return pthread_key_delete (__key); +} + +static inline void * +__gthread_getspecific (__gthread_key_t __key) +{ + return pthread_getspecific (__key); +} + +static inline int +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) +{ + return pthread_setspecific (__key, __ptr); +} + +static inline void +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + pthread_mutex_init (__mutex, __null); +} + +static inline int +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_destroy (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_lock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_lock (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_trylock (__mutex); + else + return 0; +} + + +static 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; +} + + +static inline int +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_unlock (__mutex); + else + return 0; +} +# 808 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 3 +static inline int +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_lock (__mutex); +} + +static inline int +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_trylock (__mutex); +} + + +static inline int +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthread_mutex_timedlock (__mutex, __abs_timeout); +} + + +static inline int +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_unlock (__mutex); +} + +static inline int +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_destroy (__mutex); +} +# 850 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr-default.h" 3 +static inline int +__gthread_cond_broadcast (__gthread_cond_t *__cond) +{ + return pthread_cond_broadcast (__cond); +} + +static inline int +__gthread_cond_signal (__gthread_cond_t *__cond) +{ + return pthread_cond_signal (__cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) +{ + return pthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__m= utex, + const __gthread_time_t *__abs_timeout) +{ + return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, + __gthread_recursive_mutex_t *__mutex) +{ + return __gthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_destroy (__gthread_cond_t* __cond) +{ + return pthread_cond_destroy (__cond); +} +# 149 "/usr/include/riscv64-linux-gnu/c++/13/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/include/c++/13/ext/atomicity.h" 2 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/atomic_word.h" 1 3 +# 32 "/usr/include/riscv64-linux-gnu/c++/13/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/include/c++/13/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; + +} +# 39 "/usr/include/c++/13/ext/atomicity.h" 2 3 + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + __attribute__((__always_inline__)) + inline bool + __is_single_threaded() noexcept + { + + + + return ::__libc_single_threaded; + + + + } +# 73 "/usr/include/c++/13/ext/atomicity.h" 3 + _Atomic_word + __exchange_and_add(volatile _Atomic_word*, int) noexcept; + + void + __atomic_add(volatile _Atomic_word*, int) noexcept; + + + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result =3D *__mem; + *__mem +=3D __val; + return __result; + } + + inline void + __attribute__((__always_inline__)) + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem +=3D __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); + } + + +} +# 62 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/include/c++/13/ext/concurrence.h" 1 3 +# 32 "/usr/include/c++/13/ext/concurrence.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/concurrence.h" 3 + +# 1 "/usr/include/c++/13/exception" 1 3 +# 33 "/usr/include/c++/13/exception" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/exception" 3 + + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 51 "/usr/include/c++/13/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__)); + + + + 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__)); +# 121 "/usr/include/c++/13/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"))) +{ + +# 156 "/usr/include/c++/13/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + + +# 1 "/usr/include/c++/13/bits/exception_ptr.h" 1 3 +# 36 "/usr/include/c++/13/bits/exception_ptr.h" 3 +# 1 "/usr/include/c++/13/bits/cxxabi_init_exception.h" 1 3 +# 34 "/usr/include/c++/13/bits/cxxabi_init_exception.h" 3 +=20=20=20=20=20=20=20 +# 35 "/usr/include/c++/13/bits/cxxabi_init_exception.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 39 "/usr/include/c++/13/bits/cxxabi_init_exception.h" 2 3 +# 50 "/usr/include/c++/13/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++/13/bits/exception_ptr.h" 2 3 +# 50 "/usr/include/c++/13/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++/13/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++/13/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 =3D nullptr; } +# 135 "/usr/include/c++/13/bits/exception_ptr.h" 3 + exception_ptr& + operator=3D(const exception_ptr&) noexcept; + + + exception_ptr& + operator=3D(exception_ptr&& __o) noexcept + { + exception_ptr(static_cast(__o)).swap(*this); + return *this; + } + + + ~exception_ptr() noexcept; + + void + swap(exception_ptr&) noexcept; +# 162 "/usr/include/c++/13/bits/exception_ptr.h" 3 + explicit operator bool() const noexcept + { return _M_exception_object; } + + + + + + + + friend bool + operator=3D=3D(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object =3D=3D __y._M_exception_object; } + + friend bool + operator!=3D(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object !=3D __y._M_exception_object; } + + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + +=20=20=20 + inline + exception_ptr::exception_ptr() noexcept + : _M_exception_object(0) + { } + +=20=20=20 + inline + exception_ptr::exception_ptr(const exception_ptr& __other) + noexcept + : _M_exception_object(__other._M_exception_object) + { + if (_M_exception_object) + _M_addref(); + } + +=20=20=20 + inline + exception_ptr::~exception_ptr() noexcept + { + if (_M_exception_object) + _M_release(); + } + +=20=20=20 + inline exception_ptr& + exception_ptr::operator=3D(const exception_ptr& __other) noexcept + { + exception_ptr(__other).swap(*this); + return *this; + } + +=20=20=20 + inline void + exception_ptr::swap(exception_ptr &__other) noexcept + { + void *__tmp =3D _M_exception_object; + _M_exception_object =3D __other._M_exception_object; + __other._M_exception_object =3D __tmp; + } + + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + + template +=20=20=20=20=20 + 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 =3D typename decay<_Ex>::type; + void* __e =3D __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast(&typeid(_Ex)), + __exception_ptr::__dest_thunk<_Ex2>); + if (true) + { + ::new (__e) _Ex2(__ex); + return exception_ptr(__e); + } + if (false) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +# 277 "/usr/include/c++/13/bits/exception_ptr.h" 3 + } +# 291 "/usr/include/c++/13/bits/exception_ptr.h" 3 +} + +} +# 165 "/usr/include/c++/13/exception" 2 3 +# 1 "/usr/include/c++/13/bits/nested_exception.h" 1 3 +# 40 "/usr/include/c++/13/bits/nested_exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/include/c++/13/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 =3D default; + + nested_exception& operator=3D(const nested_exception&) noexcept =3D de= fault; + + 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++/13/bits/nested_exception.h" 3 + template + [[noreturn]] + inline void + throw_with_nested(_Tp&& __t) + { + using _Up =3D typename decay<_Tp>::type; + using _CopyConstructible + =3D __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++/13/bits/nested_exception.h" 3 + template + + + + inline void + rethrow_if_nested(const _Ex& __ex) + { + const _Ex* __ptr =3D __builtin_addressof(__ex); +# 223 "/usr/include/c++/13/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 =3D dynamic_cast(__p= tr)) + __ne_ptr->rethrow_nested(); + + } + + +} + +} +# 166 "/usr/include/c++/13/exception" 2 3 +# 35 "/usr/include/c++/13/ext/concurrence.h" 2 3 + + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; + + + + inline const _Lock_policy __default_lock_policy =3D + + + + + + _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() + { (__builtin_abort()); } + + inline void + __throw_concurrence_unlock_error() + { (__builtin_abort()); } + + + inline void + __throw_concurrence_broadcast_error() + { (__builtin_abort()); } + + inline void + __throw_concurrence_wait_error() + { (__builtin_abort()); } + + + class __mutex + { + private: + + __gthread_mutex_t _M_mutex =3D { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP,= 0, { 0, 0 } } }; + + + + + __mutex(const __mutex&); + __mutex& operator=3D(const __mutex&); + + public: + __mutex() + { + + + + + } +# 144 "/usr/include/c++/13/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_lock(&_M_mutex) !=3D 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_unlock(&_M_mutex) !=3D 0) + __throw_concurrence_unlock_error(); + } + + } + + __gthread_mutex_t* gthread_mutex(void) + { return &_M_mutex; } + }; + + class __recursive_mutex + { + private: + + __gthread_recursive_mutex_t _M_mutex =3D { { 0, 0, 0, 0, PTHREAD_MUTEX= _RECURSIVE_NP, 0, { 0, 0 } } }; + + + + + __recursive_mutex(const __recursive_mutex&); + __recursive_mutex& operator=3D(const __recursive_mutex&); + + public: + __recursive_mutex() + { + + + + + } +# 199 "/usr/include/c++/13/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_lock(&_M_mutex) !=3D 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_unlock(&_M_mutex) !=3D 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=3D(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 =3D { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0= } } }; + + + + + __cond(const __cond&); + __cond& operator=3D(const __cond&); + + public: + __cond() + { + + + + + } +# 277 "/usr/include/c++/13/ext/concurrence.h" 3 + void broadcast() + { + + if (__gthread_active_p()) + { + if (__gthread_cond_broadcast(&_M_cond) !=3D 0) + __throw_concurrence_broadcast_error(); + } + + } + + void wait(__mutex *mutex) + { + + { + if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) !=3D 0) + __throw_concurrence_wait_error(); + } + + } + + void wait_recursive(__recursive_mutex *mutex) + { + + { + if (__gthread_cond_wait_recursive(&_M_cond, + mutex->gthread_recursive_mutex()) + !=3D 0) + __throw_concurrence_wait_error(); + } + + } + }; + + + +} +# 63 "/usr/include/c++/13/bits/shared_ptr_base.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +=20 +# 75 "/usr/include/c++/13/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() + { (__builtin_abort()); } + + 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 =3D 0 }; + }; + + template<> + class _Mutex_base<_S_mutex> + : public __gnu_cxx::__mutex + { + protected: + + + + enum { _S_need_barriers =3D 1 }; + }; + + template<_Lock_policy _Lp =3D __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 =3D 0; + + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept =3D 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) =3D=3D 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) =3D=3D 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&) =3D delete; + _Sp_counted_base& operator=3D(_Sp_counted_base const&) =3D 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 =3D=3D 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) =3D=3D = 0) + { + _M_use_count =3D 0; + return false; + } + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_atomic>:: + _M_add_ref_lock_nothrow() noexcept + { + + _Atomic_word __count =3D _M_get_use_count(); + do + { + if (__count =3D=3D 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 =3D=3D 0) + { + _M_dispose(); + if (--_M_weak_count =3D=3D 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) =3D=3D= 1) + { + _M_release_last_use(); + } + } + + template<> + inline void + _Sp_counted_base<_S_atomic>::_M_release() noexcept + { + ; + + constexpr bool __lock_free + =3D __atomic_always_lock_free(sizeof(long long), 0) + && __atomic_always_lock_free(sizeof(_Atomic_word), 0); + constexpr bool __double_word + =3D sizeof(long long) =3D=3D 2 * sizeof(_Atomic_word); + + + constexpr bool __aligned =3D __alignof(long long) <=3D alignof(void*= ); + if constexpr (__lock_free && __double_word && __aligned) + { + constexpr int __wordbits =3D 8 * sizeof(_Atomic_word); + constexpr int __shiftbits =3D __double_word ? __wordbits : 0; + constexpr long long __unique_ref =3D 1LL + (1LL << __shiftbits); + auto __both_counts =3D reinterpret_cast(&_M_use_count); + + ; + if (__atomic_load_n(__both_counts, 2) =3D=3D __unique_ref) + { + + + + + _M_weak_count =3D _M_use_count =3D 0; + ; + ; + _M_dispose(); + _M_destroy(); + return; + } + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) =3D=3D 1) + [[__unlikely__]] + { + _M_release_last_use_cold(); + return; + } + } + else + + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) =3D=3D= 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 =3D=3D 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 =3D __default_lock_policy> + class __weak_count; + + template<_Lock_policy _Lp =3D __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&) =3D delete; + _Sp_counted_ptr& operator=3D(const _Sp_counted_ptr&) =3D 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 =3D __alloc_rebind<_Alloc, _Sp_counted_delete= r>; + + + _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) noexc= ept + : _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__]]) noexce= pt + { + + + + return __ti =3D=3D 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)] = =3D { }; + 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<_Tp> _M_storage; + }; + + public: + using __allocator_type =3D __alloc_rebind<_Alloc, _Sp_counted_ptr_in= place>; + + + 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 + { + auto __ptr =3D const_cast::type*>(_M_ptr()); + + + + + if (&__ti =3D=3D &_Sp_make_shared_tag::_S_ti() + || + + __ti =3D=3D typeid(_Sp_make_shared_tag) + + + + ) + return __ptr; + return nullptr; + } + + _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } + + _Impl _M_impl; + }; +# 886 "/usr/include/c++/13/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 =3D 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) + { + if (true) + { + _M_pi =3D new _Sp_counted_ptr<_Ptr, _Lp>(__p); + } + if (false) + { + delete __p; + ; + } + } + + 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; + if (true) + { + typename _Sp_cd_type::__allocator_type __a2(__a); + auto __guard =3D std::__allocate_guarded(__a2); + _Sp_cd_type* __mem =3D __guard.get(); + ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); + _M_pi =3D __mem; + __guard =3D nullptr; + } + if (false) + { + __d(__p); + ; + } + } + + template + __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, + _Args&&... __args) + { + typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; + typename _Sp_cp_type::__allocator_type __a2(__a._M_a); + auto __guard =3D std::__allocate_guarded(__a2); + _Sp_cp_type* __mem =3D __guard.get(); + auto __pi =3D ::new (__mem) + _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); + __guard =3D nullptr; + _M_pi =3D __pi; + __p =3D __pi->_M_ptr(); + } +# 1024 "/usr/include/c++/13/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() =3D=3D nullptr) + return; + + using _Ptr =3D typename unique_ptr<_Tp, _Del>::pointer; + using _Del2 =3D __conditional_t::value, + reference_wrapper::type>, + _Del>; + using _Sp_cd_type + =3D _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; + using _Alloc =3D allocator<_Sp_cd_type>; + using _Alloc_traits =3D allocator_traits<_Alloc>; + _Alloc __a; + _Sp_cd_type* __mem =3D _Alloc_traits::allocate(__a, 1); + + + + _Alloc_traits::construct(__a, __mem, __r.release(), + std::forward<_Del>(__r.get_deleter())); + _M_pi =3D __mem; + } + + + explicit __shared_count(const __weak_count<_Lp>& __r); + + + explicit + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcep= t; + + ~__shared_count() noexcept + { + if (_M_pi !=3D nullptr) + _M_pi->_M_release(); + } + + __shared_count(const __shared_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi !=3D nullptr) + _M_pi->_M_add_ref_copy(); + } + + __shared_count& + operator=3D(const __shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp =3D __r._M_pi; + if (__tmp !=3D _M_pi) + { + if (__tmp !=3D nullptr) + __tmp->_M_add_ref_copy(); + if (_M_pi !=3D nullptr) + _M_pi->_M_release(); + _M_pi =3D __tmp; + } + return *this; + } + + void + _M_swap(__shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp =3D __r._M_pi; + __r._M_pi =3D _M_pi; + _M_pi =3D __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() =3D=3D 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_p= i); } + + bool + _M_less(const __weak_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_p= i); } + + + friend inline bool + operator=3D=3D(const __shared_count& __a, const __shared_count& __b)= noexcept + { return __a._M_pi =3D=3D __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 !=3D nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(const __weak_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi !=3D nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(__weak_count&& __r) noexcept + : _M_pi(__r._M_pi) + { __r._M_pi =3D nullptr; } + + ~__weak_count() noexcept + { + if (_M_pi !=3D nullptr) + _M_pi->_M_weak_release(); + } + + __weak_count& + operator=3D(const __shared_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp =3D __r._M_pi; + if (__tmp !=3D nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi !=3D nullptr) + _M_pi->_M_weak_release(); + _M_pi =3D __tmp; + return *this; + } + + __weak_count& + operator=3D(const __weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp =3D __r._M_pi; + if (__tmp !=3D nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi !=3D nullptr) + _M_pi->_M_weak_release(); + _M_pi =3D __tmp; + return *this; + } + + __weak_count& + operator=3D(__weak_count&& __r) noexcept + { + if (_M_pi !=3D nullptr) + _M_pi->_M_weak_release(); + _M_pi =3D __r._M_pi; + __r._M_pi =3D nullptr; + return *this; + } + + void + _M_swap(__weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp =3D __r._M_pi; + __r._M_pi =3D _M_pi; + _M_pi =3D __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi !=3D 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_p= i); } + + bool + _M_less(const __shared_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_p= i); } + + + friend inline bool + operator=3D=3D(const __weak_count& __a, const __weak_count& __b) noe= xcept + { return __a._M_pi =3D=3D __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 =3D=3D 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 =3D 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::value, bool =3D is_void<_Tp>::value> + class __shared_ptr_access + { + public: + using element_type =3D _Tp; + + element_type& + operator*() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() !=3D nullptr)) = __builtin_unreachable(); } while (false); + return *_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 =3D _Tp; + + element_type* + operator->() const noexcept + { + auto __ptr =3D static_cast*>(this)->get(); + ; + return __ptr; + } + }; + + + template + class __shared_ptr_access<_Tp, _Lp, true, false> + { + public: + using element_type =3D typename remove_extent<_Tp>::type; +# 1407 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 + element_type& + operator[](ptrdiff_t __i) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() !=3D nullptr)) = __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(!extent<_Tp>::value || _= _i < extent<_Tp>::value)) __builtin_unreachable(); } while (false); + return _M_get()[__i]; + } + + 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 =3D typename remove_extent<_Tp>::type; + + private: + + template + using _SafeConv + =3D typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; + + + template + using _Compatible =3D typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable =3D _Compatible<_Yp, __shared_ptr&>; + + + template::pointer> + using _UniqCompatible =3D __enable_if_t<__and_< + __sp_compatible_with<_Yp*, _Tp*>, + is_convertible<_Ptr, element_type*>, + is_move_constructible<_Del> + >::value, _Res>; + + + template + using _UniqAssignable =3D _UniqCompatible<_Yp, _Del, __shared_ptr&>; + + public: + + + using weak_type =3D __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 =3D nullptr; + } + + __shared_ptr(const __shared_ptr&) noexcept =3D default; + __shared_ptr& operator=3D(const __shared_ptr&) noexcept =3D default; + ~__shared_ptr() =3D 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 =3D 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 =3D nullptr; + } + + template> + explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) + : _M_refcount(__r._M_refcount) + { + + + _M_ptr =3D __r._M_ptr; + } + + + template> + __shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + auto __raw =3D __to_address(__r.get()); + _M_refcount =3D __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__raw); + } +# 1585 "/usr/include/c++/13/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=3D(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr =3D __r._M_ptr; + _M_refcount =3D __r._M_refcount; + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable<_Yp> + operator=3D(auto_ptr<_Yp>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } +#pragma GCC diagnostic pop + + + __shared_ptr& + operator=3D(__shared_ptr&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=3D(__shared_ptr<_Yp, _Lp>&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _UniqAssignable<_Yp, _Del> + operator=3D(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 =3D=3D nullptr || = __p !=3D _M_ptr)) __builtin_unreachable(); } 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 !=3D 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); + } +# 1697 "/usr/include/c++/13/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); +# 1731 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 + __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexce= pt + : _M_refcount(__r._M_refcount, std::nothrow) + { + _M_ptr =3D _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; + } + + friend class __weak_ptr<_Tp, _Lp>; + + private: + + template + using __esft_base_t =3D 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::ty= pe> + typename enable_if<__has_esft_base<_Yp2>::value>::type + _M_enable_shared_from_this_with(_Yp* __p) noexcept + { + if (auto __base =3D __enable_shared_from_this_base(_M_refcount, __p)) + __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); + } + + template::ty= pe> + 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; + + + + + + element_type* _M_ptr; + __shared_count<_Lp> _M_refcount; + }; + + + + template + inline bool + operator=3D=3D(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() =3D=3D __b.get(); } + + template + inline bool + operator=3D=3D(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !__a; } +# 1817 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 + template + inline bool + operator=3D=3D(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !__a; } + + template + inline bool + operator!=3D(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() !=3D __b.get(); } + + template + inline bool + operator!=3D(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + template + inline bool + operator!=3D(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 =3D typename __shared_ptr<_Tp, _Lp>::element_type; + using _Up_elt =3D typename __shared_ptr<_Up, _Lp>::element_type; + using _Vp =3D 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 =3D 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 =3D typename __shared_ptr<_Tp, _Lp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + template + inline bool + operator<=3D(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__b < __a); } + + template + inline bool + operator<=3D(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + template + inline bool + operator<=3D(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>=3D(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__a < __b); } + + template + inline bool + operator>=3D(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>=3D(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); } +# 1927 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 + template + inline __shared_ptr<_Tp, _Lp> + static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp =3D __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 =3D __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 =3D __shared_ptr<_Tp, _Lp>; + if (auto* __p =3D 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 =3D __shared_ptr<_Tp, _Lp>; + return _Sp(__r, reinterpret_cast(__r.ge= t())); + } + + + template + class __weak_ptr + { + template + using _Compatible =3D typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable =3D _Compatible<_Yp, __weak_ptr&>; + + public: + using element_type =3D typename remove_extent<_Tp>::type; + + constexpr __weak_ptr() noexcept + : _M_ptr(nullptr), _M_refcount() + { } + + __weak_ptr(const __weak_ptr&) noexcept =3D default; + + ~__weak_ptr() =3D default; +# 2009 "/usr/include/c++/13/bits/shared_ptr_base.h" 3 + template> + __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept + : _M_refcount(__r._M_refcount) + { _M_ptr =3D __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 =3D 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 =3D nullptr; } + + __weak_ptr& + operator=3D(const __weak_ptr& __r) noexcept =3D default; + + template + _Assignable<_Yp> + operator=3D(const __weak_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr =3D __r.lock().get(); + _M_refcount =3D __r._M_refcount; + return *this; + } + + template + _Assignable<_Yp> + operator=3D(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr =3D __r._M_ptr; + _M_refcount =3D __r._M_refcount; + return *this; + } + + __weak_ptr& + operator=3D(__weak_ptr&& __r) noexcept + { + __weak_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=3D(__weak_ptr<_Yp, _Lp>&& __r) noexcept + { + _M_ptr =3D __r.lock().get(); + _M_refcount =3D std::move(__r._M_refcount); + __r._M_ptr =3D nullptr; + return *this; + } + + __shared_ptr<_Tp, _Lp> + lock() const noexcept + { return __shared_ptr(*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() =3D=3D 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() =3D=3D 0) + { + _M_ptr =3D __ptr; + _M_refcount =3D __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 =3D 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=3D(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++/13/bits/shared_ptr.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 68 "/usr/include/c++/13/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++/13/bits/shared_ptr.h" 3 + template + using _NonArray =3D __enable_if_t::value, _Tp>; +# 174 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + class shared_ptr : public __shared_ptr<_Tp> + { + template + using _Constructible =3D typename enable_if< + is_constructible<__shared_ptr<_Tp>, _Args...>::value + >::type; + + template + using _Assignable =3D typename enable_if< + is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& + >::type; + + public: + + + using element_type =3D typename __shared_ptr<_Tp>::element_type; + + + + + + using weak_type =3D weak_ptr<_Tp>; + + + + + + constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } + + shared_ptr(const shared_ptr&) noexcept =3D default; + + + + + + + + template> + explicit + shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } +# 229 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 247 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + shared_ptr(nullptr_t __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 266 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } +# 286 "/usr/include/c++/13/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)) { } +# 310 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept + : __shared_ptr<_Tp>(__r, __p) { } +# 349 "/usr/include/c++/13/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)) { } +# 379 "/usr/include/c++/13/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)) { } +# 412 "/usr/include/c++/13/bits/shared_ptr.h" 3 + constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } + + shared_ptr& operator=3D(const shared_ptr&) noexcept =3D default; + + template + _Assignable&> + operator=3D(const shared_ptr<_Yp>& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=3D(__r); + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable> + operator=3D(auto_ptr<_Yp>&& __r) + { + this->__shared_ptr<_Tp>::operator=3D(std::move(__r)); + return *this; + } +#pragma GCC diagnostic pop + + + shared_ptr& + operator=3D(shared_ptr&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=3D(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=3D(shared_ptr<_Yp>&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=3D(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=3D(unique_ptr<_Yp, _Del>&& __r) + { + this->__shared_ptr<_Tp>::operator=3D(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&&...); +# 535 "/usr/include/c++/13/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=3D=3D(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b)= noexcept + { return __a.get() =3D=3D __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator=3D=3D(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !__a; } +# 580 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + [[__nodiscard__]] inline bool + operator=3D=3D(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !__a; } + + + template + [[__nodiscard__]] inline bool + operator!=3D(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) n= oexcept + { return __a.get() !=3D __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator!=3D(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + + template + [[__nodiscard__]] inline bool + operator!=3D(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) noex= cept + { + using _Tp_elt =3D typename shared_ptr<_Tp>::element_type; + using _Up_elt =3D typename shared_ptr<_Up>::element_type; + using _Vp =3D 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 =3D 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 =3D typename shared_ptr<_Tp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + + template + [[__nodiscard__]] inline bool + operator<=3D(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) n= oexcept + { return !(__b < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=3D(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=3D(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) noex= cept + { 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>=3D(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) n= oexcept + { return !(__a < __b); } + + + template + [[__nodiscard__]] inline bool + operator>=3D(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=3D(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 =3D 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 =3D 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 =3D shared_ptr<_Tp>; + if (auto* __p =3D 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 =3D shared_ptr<_Tp>; + return _Sp(__r, reinterpret_cast(__r.ge= t())); + } +# 810 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + class weak_ptr : public __weak_ptr<_Tp> + { + template + using _Constructible =3D typename enable_if< + is_constructible<__weak_ptr<_Tp>, _Arg>::value + >::type; + + template + using _Assignable =3D typename enable_if< + is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& + >::type; + + public: + constexpr weak_ptr() noexcept =3D default; + + template&>> + weak_ptr(const shared_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(const weak_ptr&) noexcept =3D default; + + template&>> + weak_ptr(const weak_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(weak_ptr&&) noexcept =3D default; + + template>> + weak_ptr(weak_ptr<_Yp>&& __r) noexcept + : __weak_ptr<_Tp>(std::move(__r)) { } + + weak_ptr& + operator=3D(const weak_ptr& __r) noexcept =3D default; + + template + _Assignable&> + operator=3D(const weak_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=3D(__r); + return *this; + } + + template + _Assignable&> + operator=3D(const shared_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=3D(__r); + return *this; + } + + weak_ptr& + operator=3D(weak_ptr&& __r) noexcept =3D default; + + template + _Assignable> + operator=3D(weak_ptr<_Yp>&& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=3D(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=3D(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; + }; +# 988 "/usr/include/c++/13/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)...); + } +# 1003 "/usr/include/c++/13/bits/shared_ptr.h" 3 + template + inline shared_ptr<_NonArray<_Tp>> + make_shared(_Args&&... __args) + { + using _Alloc =3D allocator; + _Alloc __a; + return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } +# 1152 "/usr/include/c++/13/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()); + } + }; + + + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 81 "/usr/include/c++/13/memory" 2 3 +# 1 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 1 3 +# 33 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 3 +# 1 "/usr/include/c++/13/bits/atomic_base.h" 1 3 +# 33 "/usr/include/c++/13/bits/atomic_base.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/atomic_base.h" 3 + + + + +# 1 "/usr/include/c++/13/bits/atomic_lockfree_defines.h" 1 3 +# 33 "/usr/include/c++/13/bits/atomic_lockfree_defines.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/atomic_lockfree_defines.h" 3 +# 39 "/usr/include/c++/13/bits/atomic_base.h" 2 3 +# 49 "/usr/include/c++/13/bits/atomic_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 79 "/usr/include/c++/13/bits/atomic_base.h" 3 + typedef enum memory_order + { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + + + enum __memory_order_modifier + { + __memory_order_mask =3D 0x0ffff, + __memory_order_modifier_mask =3D 0xffff0000, + __memory_order_hle_acquire =3D 0x10000, + __memory_order_hle_release =3D 0x20000 + }; + + + constexpr memory_order + operator|(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) | int(__mod)); + } + + constexpr memory_order + operator&(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) & int(__mod)); + } + + + + + constexpr memory_order + __cmpexch_failure_order2(memory_order __m) noexcept + { + return __m =3D=3D memory_order_acq_rel ? memory_order_acquire + : __m =3D=3D 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) !=3D memory_order_release + && (__m & __memory_order_mask) !=3D 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; + } +# 173 "/usr/include/c++/13/bits/atomic_base.h" 3 + template + struct atomic; + + template + struct atomic<_Tp*>; + + + + typedef bool __atomic_flag_data_type; +# 198 "/usr/include/c++/13/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 =3D default; + ~atomic_flag() noexcept =3D default; + atomic_flag(const atomic_flag&) =3D delete; + atomic_flag& operator=3D(const atomic_flag&) =3D delete; + atomic_flag& operator=3D(const atomic_flag&) volatile =3D delete; + + + constexpr atomic_flag(bool __i) noexcept + : __atomic_flag_base{ _S_init(__i) } + { } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m =3D 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 =3D memory_order_seq_cst) volatile noexc= ept + { + return __atomic_test_and_set (&_M_i, int(__m)); + } +# 284 "/usr/include/c++/13/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) void + clear(memory_order __m =3D memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + clear(memory_order __m =3D memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_ord= er_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + private: + static constexpr __atomic_flag_data_type + _S_init(bool __i) + { return __i ? 1 : 0; } + }; +# 340 "/usr/include/c++/13/bits/atomic_base.h" 3 + template + struct __atomic_base + { + using value_type =3D _ITp; + using difference_type =3D value_type; + + private: + typedef _ITp __int_type; + + static constexpr int _S_alignment =3D + sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); + + alignas(_S_alignment) __int_type _M_i ; + + public: + __atomic_base() noexcept =3D default; + ~__atomic_base() noexcept =3D default; + __atomic_base(const __atomic_base&) =3D delete; + __atomic_base& operator=3D(const __atomic_base&) =3D delete; + __atomic_base& operator=3D(const __atomic_base&) volatile =3D 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=3D(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=3D(__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+=3D(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator+=3D(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=3D(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=3D(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=3D(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=3D(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=3D(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=3D(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=3D(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=3D(__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 =3D memory_order_seq_cst) noe= xcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= quire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_co= nsume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= quire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_co= nsume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m =3D memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_re= lease)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m =3D memory_order_seq_cst) const volatile noexc= ept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_re= lease)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m =3D 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 =3D 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_failu= re_order(__m2))) __builtin_unreachable(); } 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_failu= re_order(__m2))) __builtin_unreachable(); } 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 =3D 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 =3D 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_failu= re_order(__m2))) __builtin_unreachable(); } 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_failu= re_order(__m2))) __builtin_unreachable(); } 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 =3D 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 =3D memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } +# 632 "/usr/include/c++/13/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 ; + + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PT= p); } + + public: + __atomic_base() noexcept =3D default; + ~__atomic_base() noexcept =3D default; + __atomic_base(const __atomic_base&) =3D delete; + __atomic_base& operator=3D(const __atomic_base&) =3D delete; + __atomic_base& operator=3D(const __atomic_base&) volatile =3D 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=3D(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=3D(__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, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=3D(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=3D(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=3D(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=3D(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_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 =3D memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= quire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_co= nsume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= quire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_co= nsume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m =3D memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_re= lease)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m =3D memory_order_seq_cst) const volatile noexc= ept + { + memory_order __b __attribute__ ((__unused__)) + =3D __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_re= lease)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b !=3D memory_order_ac= q_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m =3D 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 =3D 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_failu= re_order(__m2))) __builtin_unreachable(); } 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_failu= re_order(__m2))) __builtin_unreachable(); } 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_failu= re_order(__m2))) __builtin_unreachable(); } 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_failu= re_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, + int(__m1), int(__m2)); + } +# 935 "/usr/include/c++/13/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, _M_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__)) _Tp* + __clear_padding(_Tp& __val) noexcept + { + auto* __ptr =3D std::__addressof(__val); + + if constexpr (__atomic_impl::__maybe_has_padding<_Tp>()) + __builtin_clear_padding(__ptr); + + return __ptr; + } + + + template + using _Val =3D typename remove_volatile<_Tp>::type; + + 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_failu= re_order(__f))) __builtin_unreachable(); } while (false); + + using _Vp =3D _Val<_Tp>; + + if constexpr (__atomic_impl::__maybe_has_padding<_Vp>()) + { + + + alignas(_Vp) unsigned char __buf[sizeof(_Vp)]; + _Vp* __exp =3D ::new((void*)__buf) _Vp(__e); + __atomic_impl::__clear_padding(*__exp); + if (__atomic_compare_exchange(std::__addressof(__val), __exp, + __atomic_impl::__clear_padding(__i), + __is_weak, int(__s), int(__f))) + return true; + __builtin_memcpy(std::__addressof(__e), __exp, sizeof(_Vp)); + return false; + } + else + return __atomic_compare_exchange(std::__addressof(__val), + std::__addressof(__e), + std::__addressof(__i), + __is_weak, int(__s), int(__f)); + } + } +# 2020 "/usr/include/c++/13/bits/atomic_base.h" 3 + +} +# 34 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 2 3 +# 61 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 73 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 3 + struct _Sp_locker + { + _Sp_locker(const _Sp_locker&) =3D delete; + _Sp_locker& operator=3D(const _Sp_locker&) =3D 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; + + + + }; +# 100 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 3 + template + inline bool + atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) + { + + return __gthread_active_p() =3D=3D 0; + + + + } + + template + inline bool + atomic_is_lock_free(const shared_ptr<_Tp>* __p) + { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } +# 127 "/usr/include/c++/13/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); } +# 163 "/usr/include/c++/13/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= ); } +# 200 "/usr/include/c++/13/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); + } +# 249 "/usr/include/c++/13/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 =3D=3D *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x =3D std::move(*__p); + *__p =3D std::move(__w); + return true; + } + __x =3D std::move(*__v); + *__v =3D *__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 =3D=3D *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x =3D std::move(*__p); + *__p =3D std::move(__w); + return true; + } + __x =3D std::move(*__v); + *__v =3D *__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); + } +# 850 "/usr/include/c++/13/bits/shared_ptr_atomic.h" 3 + +} +# 82 "/usr/include/c++/13/memory" 2 3 + + + + +# 1 "/usr/include/c++/13/backward/auto_ptr.h" 1 3 +# 36 "/usr/include/c++/13/backward/auto_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 47 "/usr/include/c++/13/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++/13/backward/auto_ptr.h" 3 + template + class auto_ptr + { + private: + _Tp* _M_ptr; + + public: + + typedef _Tp element_type; + + + + + + + + explicit + auto_ptr(element_type* __p =3D 0) throw() : _M_ptr(__p) { } +# 118 "/usr/include/c++/13/backward/auto_ptr.h" 3 + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } +# 130 "/usr/include/c++/13/backward/auto_ptr.h" 3 + template + auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } +# 141 "/usr/include/c++/13/backward/auto_ptr.h" 3 + auto_ptr& + operator=3D(auto_ptr& __a) throw() + { + reset(__a.release()); + return *this; + } +# 158 "/usr/include/c++/13/backward/auto_ptr.h" 3 + template + auto_ptr& + operator=3D(auto_ptr<_Tp1>& __a) throw() + { + reset(__a.release()); + return *this; + } +# 176 "/usr/include/c++/13/backward/auto_ptr.h" 3 + ~auto_ptr() { delete _M_ptr; } +# 186 "/usr/include/c++/13/backward/auto_ptr.h" 3 + element_type& + operator*() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr !=3D 0)) __builti= n_unreachable(); } while (false); + return *_M_ptr; + } + + + + + + + + element_type* + operator->() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr !=3D 0)) __builti= n_unreachable(); } while (false); + return _M_ptr; + } +# 216 "/usr/include/c++/13/backward/auto_ptr.h" 3 + element_type* + get() const throw() { return _M_ptr; } +# 230 "/usr/include/c++/13/backward/auto_ptr.h" 3 + element_type* + release() throw() + { + element_type* __tmp =3D _M_ptr; + _M_ptr =3D 0; + return __tmp; + } +# 245 "/usr/include/c++/13/backward/auto_ptr.h" 3 + void + reset(element_type* __p =3D 0) throw() + { + if (__p !=3D _M_ptr) + { + delete _M_ptr; + _M_ptr =3D __p; + } + } +# 270 "/usr/include/c++/13/backward/auto_ptr.h" 3 + auto_ptr(auto_ptr_ref __ref) throw() + : _M_ptr(__ref._M_ptr) { } + + auto_ptr& + operator=3D(auto_ptr_ref __ref) throw() + { + if (__ref._M_ptr !=3D this->get()) + { + delete _M_ptr; + _M_ptr =3D __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() + { +=20=20=20=20=20 + static_assert( sizeof(_Tp1) > 0, "incomplete type" ); + _Tp1* __tmp =3D __r.get(); + _M_refcount =3D __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 + + +} +# 87 "/usr/include/c++/13/memory" 2 3 +# 101 "/usr/include/c++/13/memory" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 119 "/usr/include/c++/13/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; } + + + +} +# 154 "/usr/include/c++/13/memory" 3 +# 1 "/usr/include/c++/13/pstl/glue_memory_defs.h" 1 3 +# 13 "/usr/include/c++/13/pstl/glue_memory_defs.h" 3 +# 1 "/usr/include/c++/13/pstl/execution_defs.h" 1 3 +# 15 "/usr/include/c++/13/pstl/execution_defs.h" 3 +namespace __pstl +{ +namespace execution +{ +inline namespace v1 +{ + + +class sequenced_policy +{ + public: + + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + + +class parallel_policy +{ + public: + + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; + + +class parallel_unsequenced_policy +{ + public: + + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; + +class unsequenced_policy +{ + public: + + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + + +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::tru= e_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::t= rue_type +{ +}; + + +template +constexpr bool is_execution_policy_v =3D __pstl::execution::is_execution_p= olicy<_Tp>::value; + + +} +} + +namespace __internal +{ +template + +using __enable_if_execution_policy =3D + typename std::enable_if<__pstl::execution::is_execution_policy>::value, + _Tp>::type; + + + + + +} + +} +# 14 "/usr/include/c++/13/pstl/glue_memory_defs.h" 2 3 + +namespace std +{ + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _Inp= utIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _S= ize __n, _ForwardIterator __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _Inp= utIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _S= ize __n, _ForwardIterator __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _F= orwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +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, _ForwardItera= tor __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterato= r __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Forwar= dIterator> +uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardItera= tor __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, _Forwar= dIterator> +uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterato= r __first, _Size __n); + +} +# 155 "/usr/include/c++/13/memory" 2 3 +# 24 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" 2 +# 1 "/usr/include/c++/13/utility" 1 3 +# 58 "/usr/include/c++/13/utility" 3 +=20=20=20=20=20=20=20 +# 59 "/usr/include/c++/13/utility" 3 +# 68 "/usr/include/c++/13/utility" 3 +# 1 "/usr/include/c++/13/bits/stl_relops.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 86 "/usr/include/c++/13/bits/stl_relops.h" 3 + template + inline bool + operator!=3D(const _Tp& __x, const _Tp& __y) + { return !(__x =3D=3D __y); } +# 99 "/usr/include/c++/13/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 112 "/usr/include/c++/13/bits/stl_relops.h" 3 + template + inline bool + operator<=3D(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 125 "/usr/include/c++/13/bits/stl_relops.h" 3 + template + inline bool + operator>=3D(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 69 "/usr/include/c++/13/utility" 2 3 + + + + +# 1 "/usr/include/c++/13/initializer_list" 1 3 +# 33 "/usr/include/c++/13/initializer_list" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/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(); } +} +# 74 "/usr/include/c++/13/utility" 2 3 +# 82 "/usr/include/c++/13/utility" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 94 "/usr/include/c++/13/utility" 3 + template +=20=20=20 + 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&&) =3D delete; +# 224 "/usr/include/c++/13/utility" 3 + +} +# 25 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" 2 + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway_export.h" 1 +# 27 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" 2 + + +# 28 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" +namespace hwy { +# 37 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/aligned_allocator.= h" +using AllocPtr =3D void* (*)(void* opaque, size_t bytes); +using FreePtr =3D void (*)(void* opaque, void* memory); + + + + + +__attribute__((visibility("default"))) void* AllocateAlignedBytes(size_t p= ayload_size, + AllocPtr alloc_ptr, void* opaque_= ptr); + + + + + +__attribute__((visibility("default"))) void FreeAlignedBytes(const void* a= ligned_pointer, + FreePtr free_ptr, void* opaque_ptr); + + + + + +class AlignedDeleter { + public: + AlignedDeleter() : free_(nullptr), opaque_ptr_(nullptr) {} + AlignedDeleter(FreePtr free_ptr, void* opaque_ptr) + : free_(free_ptr), opaque_ptr_(opaque_ptr) {} + + template + void operator()(T* aligned_pointer) const { + return DeleteAlignedArray(aligned_pointer, free_, opaque_ptr_, + TypedArrayDeleter); + } + + private: + template + static void TypedArrayDeleter(void* ptr, size_t size_in_bytes) { + size_t elems =3D size_in_bytes / sizeof(T); + for (size_t i =3D 0; i < elems; i++) { + + (static_cast(ptr) + i)->~T(); + } + } + + + + using ArrayDeleter =3D void (*)(void* t_ptr, size_t t_size); + + __attribute__((visibility("default"))) static void DeleteAlignedArray(vo= id* aligned_pointer, + FreePtr free_ptr, + void* opaque_ptr, + ArrayDeleter deleter); + + FreePtr free_; + void* opaque_ptr_; +}; + + + + +template +using AlignedUniquePtr =3D std::unique_ptr; + + + + + +template +AlignedUniquePtr MakeUniqueAlignedWithAlloc(AllocPtr alloc, FreePtr fre= e, + void* opaque, Args&&... arg= s) { + T* ptr =3D static_cast(AllocateAlignedBytes(sizeof(T), alloc, opaque= )); + return AlignedUniquePtr(new (ptr) T(std::forward(args)...), + AlignedDeleter(free, opaque)); +} + + + +template +AlignedUniquePtr MakeUniqueAligned(Args&&... args) { + T* ptr =3D static_cast(AllocateAlignedBytes( + sizeof(T), nullptr, nullptr)); + return AlignedUniquePtr(new (ptr) T(std::forward(args)...), + AlignedDeleter()); +} + + +namespace detail { + + +static inline constexpr size_t ShiftCount(size_t n) { + return (n <=3D 1) ? 0 : 1 + ShiftCount(n / 2); +} + +template +T* AllocateAlignedItems(size_t items, AllocPtr alloc_ptr, void* opaque_ptr= ) { + constexpr size_t size =3D sizeof(T); + + constexpr bool is_pow2 =3D (size & (size - 1)) =3D=3D 0; + constexpr size_t bits =3D ShiftCount(size); + static_assert(!is_pow2 || (1ull << bits) =3D=3D size, "ShiftCount is inc= orrect"); + + const size_t bytes =3D is_pow2 ? items << bits : items * size; + const size_t check =3D is_pow2 ? bytes >> bits : bytes / size; + if (check !=3D items) { + return nullptr; + } + return static_cast(AllocateAlignedBytes(bytes, alloc_ptr, opaque_ptr= )); +} + +} + + + + + +template +AlignedUniquePtr MakeUniqueAlignedArrayWithAlloc( + size_t items, AllocPtr alloc, FreePtr free, void* opaque, Args&&... ar= gs) { + T* ptr =3D detail::AllocateAlignedItems(items, alloc, opaque); + if (ptr !=3D nullptr) { + for (size_t i =3D 0; i < items; i++) { + new (ptr + i) T(std::forward(args)...); + } + } + return AlignedUniquePtr(ptr, AlignedDeleter(free, opaque)); +} + +template +AlignedUniquePtr MakeUniqueAlignedArray(size_t items, Args&&... args)= { + return MakeUniqueAlignedArrayWithAlloc( + items, nullptr, nullptr, nullptr, std::forward(args)...); +} + + + +class AlignedFreer { + public: + + static void DoNothing(void* , void* ) {} + + AlignedFreer() : free_(nullptr), opaque_ptr_(nullptr) {} + AlignedFreer(FreePtr free_ptr, void* opaque_ptr) + : free_(free_ptr), opaque_ptr_(opaque_ptr) {} + + template + void operator()(T* aligned_pointer) const { + + FreeAlignedBytes(aligned_pointer, free_, opaque_ptr_); + } + + private: + FreePtr free_; + void* opaque_ptr_; +}; + + + +template +using AlignedFreeUniquePtr =3D std::unique_ptr; + + + +template +AlignedFreeUniquePtr AllocateAligned(const size_t items, AllocPtr all= oc, + FreePtr free, void* opaque) { + return AlignedFreeUniquePtr( + detail::AllocateAlignedItems(items, alloc, opaque), + AlignedFreer(free, opaque)); +} + + +template +AlignedFreeUniquePtr AllocateAligned(const size_t items) { + return AllocateAligned(items, nullptr, nullptr, nullptr); +} + +} +# 19 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" 2 + + + + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/foreach_target.h" 1 +# 23 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/foreach_target.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/detect_targets.h" 1 +# 21 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/detect_targets.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/detect_compiler_arc= h.h" 1 +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/detect_targets.h" 2 +# 24 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/foreach_target.h" 2 +# 281 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/foreach_target.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transf= orm_test.cc" 1 +# 23 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/foreach_target.h" 1 +# 24 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" 2 + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/transf= orm-inl.h" 1 +# 25 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form-inl.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" 1 +# 24 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" 1 +# 21 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" 2 +# 245 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +namespace hwy { +# 254 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +static constexpr __attribute__((unused)) size_t kMaxVectorSize =3D 4096; +# 279 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +#pragma pack(push, 1) +# 291 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +struct float16_t { + uint16_t bits; +}; + + +struct bfloat16_t { + uint16_t bits; +}; + +#pragma pack(pop) + +using float32_t =3D float; +using float64_t =3D double; + +#pragma pack(push, 1) + + + +struct alignas(16) uint128_t { + uint64_t lo; + uint64_t hi; +}; + + + +struct alignas(16) K64V64 { + uint64_t value; + uint64_t key; +}; + + + +struct alignas(8) K32V32 { + uint32_t value; + uint32_t key; +}; + +#pragma pack(pop) + +static inline __attribute__((unused)) bool operator<(const uint128_t& a, + const uint128_t& b) { + return (a.hi =3D=3D b.hi) ? a.lo < b.lo : a.hi < b.hi; +} + +static inline __attribute__((unused)) bool operator>(const uint128_t& a, + const uint128_t& b) { + return b < a; +} +static inline __attribute__((unused)) bool operator=3D=3D(const uint128_t&= a, + const uint128_t& b) { + return a.lo =3D=3D b.lo && a.hi =3D=3D b.hi; +} + +static inline __attribute__((unused)) bool operator<(const K64V64& a, + const K64V64& b) { + return a.key < b.key; +} + +static inline __attribute__((unused)) bool operator>(const K64V64& a, + const K64V64& b) { + return b < a; +} +static inline __attribute__((unused)) bool operator=3D=3D(const K64V64& a, + const K64V64& b) { + return a.key =3D=3D b.key; +} + +static inline __attribute__((unused)) bool operator<(const K32V32& a, + const K32V32& b) { + return a.key < b.key; +} + +static inline __attribute__((unused)) bool operator>(const K32V32& a, + const K32V32& b) { + return b < a; +} +static inline __attribute__((unused)) bool operator=3D=3D(const K32V32& a, + const K32V32& b) { + return a.key =3D=3D b.key; +} + + + + +template +struct EnableIfT {}; +template <> +struct EnableIfT { + using type =3D void; +}; + +template +using EnableIf =3D typename EnableIfT::type; + +template +struct IsSameT { + enum { value =3D 0 }; +}; + +template +struct IsSameT { + enum { value =3D 1 }; +}; + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr bool IsSame() { + return IsSameT::value; +} +# 449 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +template +struct SizeTag {}; + +template +struct RemoveConstT { + using type =3D T; +}; +template +struct RemoveConstT { + using type =3D T; +}; + +template +using RemoveConst =3D typename RemoveConstT::type; + +template +struct RemoveRefT { + using type =3D T; +}; +template +struct RemoveRefT { + using type =3D T; +}; + +template +using RemoveRef =3D typename RemoveRefT::type; + + + + +namespace detail { + +template +struct Relations; +template <> +struct Relations { + using Unsigned =3D uint8_t; + using Signed =3D int8_t; + using Wide =3D uint16_t; + enum { is_signed =3D 0, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint8_t; + using Signed =3D int8_t; + using Wide =3D int16_t; + enum { is_signed =3D 1, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint16_t; + using Signed =3D int16_t; + using Wide =3D uint32_t; + using Narrow =3D uint8_t; + enum { is_signed =3D 0, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint16_t; + using Signed =3D int16_t; + using Wide =3D int32_t; + using Narrow =3D int8_t; + enum { is_signed =3D 1, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint32_t; + using Signed =3D int32_t; + using Float =3D float; + using Wide =3D uint64_t; + using Narrow =3D uint16_t; + enum { is_signed =3D 0, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint32_t; + using Signed =3D int32_t; + using Float =3D float; + using Wide =3D int64_t; + using Narrow =3D int16_t; + enum { is_signed =3D 1, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint64_t; + using Signed =3D int64_t; + using Float =3D double; + using Wide =3D uint128_t; + using Narrow =3D uint32_t; + enum { is_signed =3D 0, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint64_t; + using Signed =3D int64_t; + using Float =3D double; + using Narrow =3D int32_t; + enum { is_signed =3D 1, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint128_t; + using Narrow =3D uint64_t; + enum { is_signed =3D 0, is_float =3D 0 }; +}; +template <> +struct Relations { + using Unsigned =3D uint16_t; + using Signed =3D int16_t; + using Float =3D float16_t; + using Wide =3D float; + enum { is_signed =3D 1, is_float =3D 1 }; +}; +template <> +struct Relations { + using Unsigned =3D uint16_t; + using Signed =3D int16_t; + using Wide =3D float; + enum { is_signed =3D 1, is_float =3D 1 }; +}; +template <> +struct Relations { + using Unsigned =3D uint32_t; + using Signed =3D int32_t; + using Float =3D float; + using Wide =3D double; + using Narrow =3D float16_t; + enum { is_signed =3D 1, is_float =3D 1 }; +}; +template <> +struct Relations { + using Unsigned =3D uint64_t; + using Signed =3D int64_t; + using Float =3D double; + using Narrow =3D float; + enum { is_signed =3D 1, is_float =3D 1 }; +}; + +template +struct TypeFromSize; +template <> +struct TypeFromSize<1> { + using Unsigned =3D uint8_t; + using Signed =3D int8_t; +}; +template <> +struct TypeFromSize<2> { + using Unsigned =3D uint16_t; + using Signed =3D int16_t; +}; +template <> +struct TypeFromSize<4> { + using Unsigned =3D uint32_t; + using Signed =3D int32_t; + using Float =3D float; +}; +template <> +struct TypeFromSize<8> { + using Unsigned =3D uint64_t; + using Signed =3D int64_t; + using Float =3D double; +}; +template <> +struct TypeFromSize<16> { + using Unsigned =3D uint128_t; +}; + +} + + +template +using MakeUnsigned =3D typename detail::Relations::Unsigned; +template +using MakeSigned =3D typename detail::Relations::Signed; +template +using MakeFloat =3D typename detail::Relations::Float; + + +template +using MakeWide =3D typename detail::Relations::Wide; +template +using MakeNarrow =3D typename detail::Relations::Narrow; + + +template +using UnsignedFromSize =3D typename detail::TypeFromSize::Unsigned; +template +using SignedFromSize =3D typename detail::TypeFromSize::Signed; +template +using FloatFromSize =3D typename detail::TypeFromSize::Float; + + +using UnsignedTag =3D SizeTag<0>; +using SignedTag =3D SizeTag<0x100>; +using FloatTag =3D SizeTag<0x200>; + +template > +constexpr auto TypeTag() -> hwy::SizeTag<((R::is_signed + R::is_float) << = 8)> { + return hwy::SizeTag<((R::is_signed + R::is_float) << 8)>(); +} + + +using NonFloatTag =3D SizeTag<0x400>; + +template > +constexpr auto IsFloatTag() -> hwy::SizeTag<(R::is_float ? 0x200 : 0x400)>= { + return hwy::SizeTag<(R::is_float ? 0x200 : 0x400)>(); +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr bool IsFloat() { + + + return IsSame() || IsSame(); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr bool IsSpecialFloat() { + return IsSame() || IsSame(); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr bool IsSigned() { + return T(0) > T(-1); +} +template <> +constexpr bool IsSigned() { + return true; +} +template <> +constexpr bool IsSigned() { + return true; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr T LimitsMax() { + static_assert(!IsFloat(), "Only for integer types"); + using TU =3D MakeUnsigned; + return static_cast(IsSigned() ? (static_cast(~0ull) >> 1) + : static_cast(~0ull)); +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr T LimitsMin() { + static_assert(!IsFloat(), "Only for integer types"); + return IsSigned() ? T(-1) - LimitsMax() : T(0); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr T LowestValue() { + return LimitsMin(); +} +template <> +constexpr float LowestValue() { + return -3.402823466e+38F; +} +template <> +constexpr double LowestValue() { + return -1.7976931348623158e+308; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr T HighestValue() { + return LimitsMax(); +} +template <> +constexpr float HighestValue() { + return 3.402823466e+38F; +} +template <> +constexpr double HighestValue() { + return 1.7976931348623158e+308; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) constexpr T Epsilon() { + return 1; +} +template <> +constexpr float Epsilon() { + return 1.192092896e-7f; +} +template <> +constexpr double Epsilon() { + return 2.2204460492503131e-16; +} + + +template +constexpr int MantissaBits() { + static_assert(sizeof(T) =3D=3D 0, "Only instantiate the specializations"= ); + return 0; +} +template <> +constexpr int MantissaBits() { + return 23; +} +template <> +constexpr int MantissaBits() { + return 52; +} + + + +template +constexpr MakeSigned MaxExponentTimes2() { + return -(MakeSigned{1} << (MantissaBits() + 1)); +} + + +template +constexpr MakeUnsigned SignMask() { + return MakeUnsigned{1} << (sizeof(T) * 8 - 1); +} + + +template +constexpr MakeUnsigned ExponentMask() { + return (~(MakeUnsigned{1} << MantissaBits()) + 1) & ~SignMask(); +} + + +template +constexpr MakeUnsigned MantissaMask() { + return (MakeUnsigned{1} << MantissaBits()) - 1; +} + + + +template +constexpr T MantissaEnd() { + static_assert(sizeof(T) =3D=3D 0, "Only instantiate the specializations"= ); + return 0; +} +template <> +constexpr float MantissaEnd() { + return 8388608.0f; +} +template <> +constexpr double MantissaEnd() { + + return 4503599627370496.0; +} + + +template +constexpr int ExponentBits() { + + return 8 * sizeof(T) - 1 - MantissaBits(); +} + + + + +template +constexpr MakeSigned MaxExponentField() { + return (MakeSigned{1} << ExponentBits()) - 1; +} + + + + +template +constexpr inline T1 DivCeil(T1 a, T2 b) { + return (a + b - 1) / b; +} + + +constexpr inline size_t RoundUpTo(size_t what, size_t align) { + return DivCeil(what, align) * align; +} + + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t Num0BitsBelowLS1Bit_Nonzero32(const uint32_t x) { + + + + + + return static_cast(__builtin_ctz(x)); + +} + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t Num0BitsBelowLS1Bit_Nonzero64(const uint64_t x) { +# 859 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" + return static_cast(__builtin_ctzll(x)); + +} + + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t Num0BitsAboveMS1Bit_Nonzero32(const uint32_t x) { + + + + + + return static_cast(__builtin_clz(x)); + +} + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t Num0BitsAboveMS1Bit_Nonzero64(const uint64_t x) { +# 894 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" + return static_cast(__builtin_clzll(x)); + +} + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t PopCount(uint64_t x) { + + return static_cast(__builtin_popcountll(x)); +# 919 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +} + + + + +template + constexpr size_t FloorLog2(TI x) { + return x =3D=3D TI{1} + ? 0 + : static_cast(FloorLog2(static_cast(x >> 1)) + 1); +} + +template + constexpr size_t CeilLog2(TI x) { + return x =3D=3D TI{1} + ? 0 + : static_cast(FloorLog2(static_cast(x - 1)) + 1); +} + +template +inline __attribute__((always_inline)) constexpr T AddWithWraparound(hwy::F= loatTag , T t, size_t n) { + return t + static_cast(n); +} + +template +inline __attribute__((always_inline)) constexpr T AddWithWraparound(hwy::N= onFloatTag , T t, + size_t n) { + using TU =3D MakeUnsigned; + return static_cast( + static_cast(static_cast(t) + static_cast(n)) & + hwy::LimitsMax()); +} + + + + + + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) uint64_t Mul128(uint64_t a, uint64_t b, uint64_t* __res= trict__ upper) { + + __uint128_t product =3D (__uint128_t)a * (__uint128_t)b; + *upper =3D (uint64_t)(product >> 64); + return (uint64_t)(product & 0xFFFFFFFFFFFFFFFFULL); +# 974 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" +} + + + + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void CopyBytes(const From* from, To* to) { + + + + __builtin_memcpy( + static_cast(to), static_cast(from), kBytes); + +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void CopySameSize(const From* __restrict__ from, To* __= restrict__ to) { + static_assert(sizeof(From) =3D=3D sizeof(To), ""); + CopyBytes(from, to); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void ZeroBytes(To* to) { + + + + __builtin_memset(to, 0, kBytes); + +} + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) float F32FromBF16(bfloat16_t bf) { + uint32_t bits =3D bf.bits; + bits <<=3D 16; + float f; + CopySameSize(&bits, &f); + return f; +} + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) bfloat16_t BF16FromF32(float f) { + uint32_t bits; + CopySameSize(&f, &bits); + bfloat16_t bf; + bf.bits =3D static_cast(bits >> 16); + return bf; +} + +__attribute__((visibility("default"))) __attribute__((noreturn)) void __at= tribute__((__format__(__printf__, 3, 4))) + Abort(const char* file, int line, const char* format, ...); + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void PreventElision(T&& output) { +# 1041 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/base.h" + asm volatile("" : "+r"(output) : : "memory"); + +} + +} +# 25 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" 2 +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" 1 +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" +# 1 "/usr/include/c++/13/vector" 1 3 +# 58 "/usr/include/c++/13/vector" 3 +=20=20=20=20=20=20=20 +# 59 "/usr/include/c++/13/vector" 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/stl_vector.h" 1 3 +# 78 "/usr/include/c++/13/bits/stl_vector.h" 3 + +# 78 "/usr/include/c++/13/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 =3D __x._M_finish =3D __x._M_end_of_storage =3D pointer();= } + + + + void + _M_copy_data(_Vector_impl_data const& __x) noexcept + { + _M_start =3D __x._M_start; + _M_finish =3D __x._M_finish; + _M_end_of_storage =3D __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)) + { } +# 291 "/usr/include/c++/13/bits/stl_vector.h" 3 + }; + + public: + typedef _Alloc allocator_type; + +=20=20=20=20=20 + _Tp_alloc_type& + _M_get_Tp_allocator() noexcept + { return this->_M_impl; } + +=20=20=20=20=20 + const _Tp_alloc_type& + _M_get_Tp_allocator() const noexcept + { return this->_M_impl; } + +=20=20=20=20=20 + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Tp_allocator()); } + + + _Vector_base() =3D default; + + + + +=20=20=20=20=20 + _Vector_base(const allocator_type& __a) noexcept + : _M_impl(__a) { } + + + +=20=20=20=20=20 + _Vector_base(size_t __n) + : _M_impl() + { _M_create_storage(__n); } + + +=20=20=20=20=20 + _Vector_base(size_t __n, const allocator_type& __a) + : _M_impl(__a) + { _M_create_storage(__n); } + + + _Vector_base(_Vector_base&&) =3D default; + + + +=20=20=20=20=20 + _Vector_base(_Tp_alloc_type&& __a) noexcept + : _M_impl(std::move(__a)) { } + +=20=20=20=20=20 + _Vector_base(_Vector_base&& __x, const allocator_type& __a) + : _M_impl(__a) + { + if (__x.get_allocator() =3D=3D __a) + this->_M_impl._M_swap_data(__x._M_impl); + else + { + size_t __n =3D __x._M_impl._M_finish - __x._M_impl._M_start; + _M_create_storage(__n); + } + } + + +=20=20=20=20=20 + _Vector_base(const allocator_type& __a, _Vector_base&& __x) + : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) + { } + + +=20=20=20=20=20 + ~_Vector_base() noexcept + { + _M_deallocate(_M_impl._M_start, + _M_impl._M_end_of_storage - _M_impl._M_start); + } + + public: + _Vector_impl _M_impl; + +=20=20=20=20=20 + pointer + _M_allocate(size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + return __n !=3D 0 ? _Tr::allocate(_M_impl, __n) : pointer(); + } + +=20=20=20=20=20 + 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: +=20=20=20=20=20 + void + _M_create_storage(size_t __n) + { + this->_M_impl._M_start =3D this->_M_allocate(__n); + this->_M_impl._M_finish =3D this->_M_impl._M_start; + this->_M_impl._M_end_of_storage =3D this->_M_impl._M_start + __n; + } + }; +# 422 "/usr/include/c++/13/bits/stl_vector.h" 3 + template > + class vector : protected _Vector_base<_Tp, _Alloc> + { +# 435 "/usr/include/c++/13/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() =3D default; +# 535 "/usr/include/c++/13/bits/stl_vector.h" 3 + explicit +=20=20=20=20=20 + vector(const allocator_type& __a) noexcept + : _Base(__a) { } +# 549 "/usr/include/c++/13/bits/stl_vector.h" 3 + explicit +=20=20=20=20=20 + vector(size_type __n, const allocator_type& __a =3D allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_default_initialize(__n); } +# 563 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector(size_type __n, const value_type& __value, + const allocator_type& __a =3D allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_fill_initialize(__n, __value); } +# 595 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector(const vector& __x) + : _Base(__x.size(), + _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) + { + this->_M_impl._M_finish =3D + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } +# 615 "/usr/include/c++/13/bits/stl_vector.h" 3 + vector(vector&&) noexcept =3D default; + + +=20=20=20=20=20 + vector(const vector& __x, const __type_identity_t& _= _a) + : _Base(__x.size(), __a) + { + this->_M_impl._M_finish =3D + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + private: +=20=20=20=20=20 + vector(vector&& __rv, const allocator_type& __m, true_type) noexcept + : _Base(__m, std::move(__rv)) + { } + +=20=20=20=20=20 + vector(vector&& __rv, const allocator_type& __m, false_type) + : _Base(__m) + { + if (__rv.get_allocator() =3D=3D __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 =3D + std::__uninitialized_move_a(__rv.begin(), __rv.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + __rv.clear(); + } + } + + public: + +=20=20=20=20=20 + 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_equ= al{}) + { } +# 672 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector(initializer_list __l, + const allocator_type& __a =3D allocator_type()) + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +# 699 "/usr/include/c++/13/bits/stl_vector.h" 3 + template> + + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a =3D allocator_type()) + : _Base(__a) + { + _M_range_initialize(__first, __last, + std::__iterator_category(__first)); + } +# 727 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + ~vector() noexcept + { + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } +# 744 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector& + operator=3D(const vector& __x); +# 759 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector& + operator=3D(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage =3D + _Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); + return *this; + } +# 781 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + vector& + operator=3D(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + return *this; + } +# 801 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } +# 819 "/usr/include/c++/13/bits/stl_vector.h" 3 + template> + + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } +# 848 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + assign(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + } + + + + 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 + { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start)= ; } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return _S_max_size(_M_get_Tp_allocator()); } +# 1006 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + 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); + } +# 1027 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + 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); + } +# 1061 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + + + + + + [[__nodiscard__]] + size_type + capacity() const noexcept + { return size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); } + + + + + + [[__nodiscard__]] + bool + empty() const noexcept + { return begin() =3D=3D end(); } +# 1103 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + reserve(size_type __n); +# 1119 "/usr/include/c++/13/bits/stl_vector.h" 3 + [[__nodiscard__]] + reference + operator[](size_type __n) noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } +# 1138 "/usr/include/c++/13/bits/stl_vector.h" 3 + [[__nodiscard__]] + const_reference + operator[](size_type __n) const noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } + + protected: + +=20=20=20=20=20 + void + _M_range_check(size_type __n) const + { + if (__n >=3D this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu= ) >=3D this->size() " "(which is %zu)") + + , + __n, this->size()); + } + + public: +# 1171 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } +# 1190 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + + + + + [[__nodiscard__]] + reference + front() noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + ; + return *(end() - 1); + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + ; + return *(end() - 1); + } +# 1253 "/usr/include/c++/13/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); } +# 1274 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + push_back(const value_type& __x) + { + if (this->_M_impl._M_finish !=3D 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_insert(end(), __x); + } + + +=20=20=20=20=20 + void + push_back(value_type&& __x) + { emplace_back(std::move(__x)); } + + template + + + reference + + + + emplace_back(_Args&&... __args); +# 1315 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + pop_back() noexcept + { + ; + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + ; + } +# 1338 "/usr/include/c++/13/bits/stl_vector.h" 3 + template + + iterator + emplace(const_iterator __position, _Args&&... __args) + { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } +# 1355 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __position, const value_type& __x); +# 1386 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_insert_rval(__position, std::move(__x)); } +# 1404 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __position, initializer_list __l) + { + auto __offset =3D __position - cbegin(); + _M_range_insert(begin() + __offset, __l.begin(), __l.end(), + std::random_access_iterator_tag()); + return begin() + __offset; + } +# 1430 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __position, size_type __n, const value_type& _= _x) + { + difference_type __offset =3D __position - cbegin(); + _M_fill_insert(begin() + __offset, __n, __x); + return begin() + __offset; + } +# 1473 "/usr/include/c++/13/bits/stl_vector.h" 3 + template> + + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + difference_type __offset =3D __position - cbegin(); + _M_range_insert(begin() + __offset, __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1526 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + + erase(const_iterator __position) + { return _M_erase(begin() + (__position - cbegin())); } +# 1554 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + iterator + + erase(const_iterator __first, const_iterator __last) + { + const auto __beg =3D begin(); + const auto __cbeg =3D cbegin(); + return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); + } +# 1579 "/usr/include/c++/13/bits/stl_vector.h" 3 +=20=20=20=20=20 + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate= _on_container_swap::value || _M_get_Tp_allocator() =3D=3D __x._M_get_Tp_all= ocator())) __builtin_unreachable(); } 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()); + } + + + + + + + +=20=20=20=20=20 + void + clear() noexcept + { _M_erase_at_end(this->_M_impl._M_start); } + + protected: + + + + + template + + pointer + _M_allocate_and_copy(size_type __n, + _ForwardIterator __first, _ForwardIterator __last) + { + pointer __result =3D this->_M_allocate(__n); + if (true) + { + std::__uninitialized_copy_a(__first, __last, __result, + _M_get_Tp_allocator()); + return __result; + } + if (false) + { + _M_deallocate(__result, __n); + ; + } + } +# 1659 "/usr/include/c++/13/bits/stl_vector.h" 3 + template + + void + _M_range_initialize(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + if (true) { + for (; __first !=3D __last; ++__first) + + emplace_back(*__first); + + + + } if (false) { + clear(); + ; + } + } + + + template + + void + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n =3D std::distance(__first, __last); + this->_M_impl._M_start + =3D this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); + this->_M_impl._M_end_of_storage =3D this->_M_impl._M_start + __n; + this->_M_impl._M_finish =3D + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + + +=20=20=20=20=20 + void + _M_fill_initialize(size_type __n, const value_type& __value) + { + this->_M_impl._M_finish =3D + std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, + _M_get_Tp_allocator()); + } + + + +=20=20=20=20=20 + void + _M_default_initialize(size_type __n) + { + this->_M_impl._M_finish =3D + std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, + _M_get_Tp_allocator()); + } +# 1725 "/usr/include/c++/13/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); + + + +=20=20=20=20=20 + 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); + + + +=20=20=20=20=20 + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + + +=20=20=20=20=20 + void + _M_default_append(size_type __n); + +=20=20=20=20=20 + bool + _M_shrink_to_fit(); +# 1824 "/usr/include/c++/13/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=3D(const _Storage&) =3D 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); + + +=20=20=20=20=20 + iterator + _M_insert_rval(const_iterator __position, value_type&& __v); + + + template + + iterator + _M_emplace_aux(const_iterator __position, _Args&&... __args); + + +=20=20=20=20=20 + iterator + _M_emplace_aux(const_iterator __position, value_type&& __v) + { return _M_insert_rval(__position, std::move(__v)); } + + + +=20=20=20=20=20 + 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 =3D 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 + =3D __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + const size_t __allocmax =3D _Alloc_traits::max_size(__a); + return (std::min)(__diffmax, __allocmax); + } + + + + + +=20=20=20=20=20 + void + _M_erase_at_end(pointer __pos) noexcept + { + if (size_type __n =3D this->_M_impl._M_finish - __pos) + { + std::_Destroy(__pos, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish =3D __pos; + ; + } + } + +=20=20=20=20=20 + iterator + _M_erase(iterator __position); + +=20=20=20=20=20 + iterator + _M_erase(iterator __first, iterator __last); + + + private: + + + +=20=20=20=20=20 + 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()); + } + + + +=20=20=20=20=20 + void + _M_move_assign(vector&& __x, false_type) + { + if (__x._M_get_Tp_allocator() =3D=3D 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); } +# 2010 "/usr/include/c++/13/bits/stl_vector.h" 3 + }; + + + template::value_type, + typename _Allocator =3D allocator<_ValT>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireAllocator<_Allocator>> + vector(_InputIterator, _InputIterator, _Allocator =3D _Allocator()) + -> vector<_ValT, _Allocator>; +# 2032 "/usr/include/c++/13/bits/stl_vector.h" 3 + template +=20=20=20 + inline bool + operator=3D=3D(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Allo= c>& __y) + { return (__x.size() =3D=3D __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin())); } +# 2072 "/usr/include/c++/13/bits/stl_vector.h" 3 + template + 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 + inline bool + operator!=3D(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>= & __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& _= _y) + { return __y < __x; } + + + template + inline bool + operator<=3D(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>= & __y) + { return !(__y < __x); } + + + template + inline bool + operator>=3D(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>= & __y) + { return !(__x < __y); } + + + + template +=20=20=20 + 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> + { }; + } + + + +} +# 67 "/usr/include/c++/13/vector" 2 3 +# 1 "/usr/include/c++/13/bits/stl_bvector.h" 1 3 +# 64 "/usr/include/c++/13/bits/stl_bvector.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + typedef unsigned long _Bit_type; + enum { _S_word_bit =3D int(8 * sizeof(_Bit_type)) }; + + __attribute__((__nonnull__)) +=20 + void + __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; + + + + struct _Bit_reference + { + _Bit_type * _M_p; + _Bit_type _M_mask; + +=20=20=20 + _Bit_reference(_Bit_type * __x, _Bit_type __y) + : _M_p(__x), _M_mask(__y) { } + +=20=20=20 + _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } + + + _Bit_reference(const _Bit_reference&) =3D default; + + + [[__nodiscard__]] + operator bool() const noexcept + { return !!(*_M_p & _M_mask); } + +=20=20=20 + _Bit_reference& + operator=3D(bool __x) noexcept + { + if (__x) + *_M_p |=3D _M_mask; + else + *_M_p &=3D ~_M_mask; + return *this; + } +# 121 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20 + _Bit_reference& + operator=3D(const _Bit_reference& __x) noexcept + { return *this =3D bool(__x); } + + [[__nodiscard__]] + bool + operator=3D=3D(const _Bit_reference& __x) const + { return bool(*this) =3D=3D bool(__x); } + + [[__nodiscard__]] + bool + operator<(const _Bit_reference& __x) const + { return !bool(*this) && bool(__x); } + +=20=20=20 + void + flip() noexcept + { *_M_p ^=3D _M_mask; } + + +=20=20=20 + friend void + swap(_Bit_reference __x, _Bit_reference __y) noexcept + { + bool __tmp =3D __x; + __x =3D __y; + __y =3D __tmp; + } + +=20=20=20 + friend void + swap(_Bit_reference __x, bool& __y) noexcept + { + bool __tmp =3D __x; + __x =3D __y; + __y =3D __tmp; + } + +=20=20=20 + friend void + swap(bool& __x, _Bit_reference __y) noexcept + { + bool __tmp =3D __x; + __x =3D __y; + __y =3D __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; + +=20=20=20 + _Bit_iterator_base(_Bit_type * __x, unsigned int __y) + : _M_p(__x), _M_offset(__y) { } + +=20=20=20 + void + _M_bump_up() + { + if (_M_offset++ =3D=3D int(_S_word_bit) - 1) + { + _M_offset =3D 0; + ++_M_p; + } + } + +=20=20=20 + void + _M_bump_down() + { + if (_M_offset-- =3D=3D 0) + { + _M_offset =3D int(_S_word_bit) - 1; + --_M_p; + } + } + +=20=20=20 + void + _M_incr(ptrdiff_t __i) + { + difference_type __n =3D __i + _M_offset; + _M_p +=3D __n / int(_S_word_bit); + __n =3D __n % int(_S_word_bit); + if (__n < 0) + { + __n +=3D int(_S_word_bit); + --_M_p; + } + _M_offset =3D static_cast(__n); + } + + [[__nodiscard__]] + friend bool + operator=3D=3D(const _Bit_iterator_base& __x, const _Bit_iterator_base= & __y) + { return __x._M_p =3D=3D __y._M_p && __x._M_offset =3D=3D __y._M_offse= t; } +# 237 "/usr/include/c++/13/bits/stl_bvector.h" 3 + [[__nodiscard__]] + friend bool + operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return __x._M_p < __y._M_p + || (__x._M_p =3D=3D __y._M_p && __x._M_offset < __y._M_offset); + } + + [[__nodiscard__]] + friend bool + operator!=3D(const _Bit_iterator_base& __x, const _Bit_iterator_base& = __y) + { return !(__x =3D=3D __y); } + + [[__nodiscard__]] + friend bool + operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return __y < __x; } + + [[__nodiscard__]] + friend bool + operator<=3D(const _Bit_iterator_base& __x, const _Bit_iterator_base& = __y) + { return !(__y < __x); } + + [[__nodiscard__]] + friend bool + operator>=3D(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) + { + 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; + +=20=20=20 + _Bit_iterator() : _Bit_iterator_base(0, 0) { } + +=20=20=20 + _Bit_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + +=20=20=20 + iterator + _M_const_cast() const + { return *this; } + + [[__nodiscard__]] + reference + operator*() const + { return reference(_M_p, 1UL << _M_offset); } + +=20=20=20 + iterator& + operator++() + { + _M_bump_up(); + return *this; + } + +=20=20=20 + iterator + operator++(int) + { + iterator __tmp =3D *this; + _M_bump_up(); + return __tmp; + } + +=20=20=20 + iterator& + operator--() + { + _M_bump_down(); + return *this; + } + +=20=20=20 + iterator + operator--(int) + { + iterator __tmp =3D *this; + _M_bump_down(); + return __tmp; + } + +=20=20=20 + iterator& + operator+=3D(difference_type __i) + { + _M_incr(__i); + return *this; + } + +=20=20=20 + iterator& + operator-=3D(difference_type __i) + { + *this +=3D -__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 =3D __x; + __tmp +=3D __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 =3D __x; + __tmp -=3D __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; + +=20=20=20 + _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } + +=20=20=20 + _Bit_const_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + +=20=20=20 + _Bit_const_iterator(const _Bit_iterator& __x) + : _Bit_iterator_base(__x._M_p, __x._M_offset) { } + +=20=20=20 + _Bit_iterator + _M_const_cast() const + { return _Bit_iterator(_M_p, _M_offset); } + + [[__nodiscard__]] + const_reference + operator*() const + { return _Bit_reference(_M_p, 1UL << _M_offset); } + +=20=20=20 + const_iterator& + operator++() + { + _M_bump_up(); + return *this; + } + +=20=20=20 + const_iterator + operator++(int) + { + const_iterator __tmp =3D *this; + _M_bump_up(); + return __tmp; + } + +=20=20=20 + const_iterator& + operator--() + { + _M_bump_down(); + return *this; + } + +=20=20=20 + const_iterator + operator--(int) + { + const_iterator __tmp =3D *this; + _M_bump_down(); + return __tmp; + } + +=20=20=20 + const_iterator& + operator+=3D(difference_type __i) + { + _M_incr(__i); + return *this; + } + +=20=20=20 + const_iterator& + operator-=3D(difference_type __i) + { + *this +=3D -__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 =3D __x; + __tmp +=3D __n; + return __tmp; + } + + [[__nodiscard__]] + friend const_iterator + operator-(const const_iterator& __x, difference_type __n) + { + const_iterator __tmp =3D __x; + __tmp -=3D __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; +# 514 "/usr/include/c++/13/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&) =3D default; + + _Bvector_impl_data& + operator=3D(const _Bvector_impl_data&) =3D 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 =3D __x; + __x._M_reset(); + } + + + + void + _M_reset() noexcept + { *this =3D _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; + +=20=20=20=20=20 + _Bit_alloc_type& + _M_get_Bit_allocator() noexcept + { return this->_M_impl; } + +=20=20=20=20=20 + const _Bit_alloc_type& + _M_get_Bit_allocator() const noexcept + { return this->_M_impl; } + +=20=20=20=20=20 + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Bit_allocator()); } + + + _Bvector_base() =3D default; + + + + +=20=20=20=20=20 + _Bvector_base(const allocator_type& __a) + : _M_impl(__a) { } + + + _Bvector_base(_Bvector_base&&) =3D default; + +=20=20=20=20=20 + _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexce= pt + : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) + { } + + +=20=20=20=20=20 + ~_Bvector_base() + { this->_M_deallocate(); } + + protected: + _Bvector_impl _M_impl; + +=20=20=20=20=20 + _Bit_pointer + _M_allocate(size_t __n) + { + _Bit_pointer __p =3D _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); +# 652 "/usr/include/c++/13/bits/stl_bvector.h" 3 + return __p; + } + +=20=20=20=20=20 + void + _M_deallocate() + { + if (_M_impl._M_start._M_p) + { + const size_t __n =3D _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(); + } + } + + +=20=20=20=20=20 + 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); } + }; +# 701 "/usr/include/c++/13/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; + +=20=20=20=20=20 + 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() =3D default; + + + + +=20=20=20=20=20 + explicit + vector(const allocator_type& __a) + : _Base(__a) { } + + +=20=20=20=20=20 + explicit + vector(size_type __n, const allocator_type& __a =3D allocator_type()) + : vector(__n, false, __a) + { } + +=20=20=20=20=20 + vector(size_type __n, const bool& __value, + const allocator_type& __a =3D allocator_type()) + + + + + + : _Base(__a) + { + _M_initialize(__n); + _M_initialize_value(__value); + } + +=20=20=20=20=20 + vector(const vector& __x) + : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocato= r())) + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + } + + + vector(vector&&) =3D default; + + private: +=20=20=20=20=20 + vector(vector&& __x, const allocator_type& __a, true_type) noexcept + : _Base(std::move(__x), __a) + { } + +=20=20=20=20=20 + vector(vector&& __x, const allocator_type& __a, false_type) + : _Base(__a) + { + if (__x.get_allocator() =3D=3D __a) + this->_M_move_data(std::move(__x)); + else + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + __x.clear(); + } + } + + public: +=20=20=20=20=20 + 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{}) + { } + +=20=20=20=20=20 + vector(const vector& __x, const __type_identity_t& _= _a) + : _Base(__a) + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + } + +=20=20=20=20=20 + vector(initializer_list __l, + const allocator_type& __a =3D 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 =3D allocator_type()) + : _Base(__a) + { + _M_initialize_range(__first, __last, + std::__iterator_category(__first)); + } +# 850 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20=20=20 + ~vector() noexcept { } + +=20=20=20=20=20 + vector& + operator=3D(const vector& __x) + { + if (&__x =3D=3D this) + return *this; + + if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) + { + if (this->_M_get_Bit_allocator() !=3D __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 =3D _M_copy_aligned(__x.begin(), __x.end(), + begin()); + return *this; + } + + +=20=20=20=20=20 + vector& + operator=3D(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_mov= e()) + { + if (_Bit_alloc_traits::_S_propagate_on_move_assign() + || this->_M_get_Bit_allocator() =3D=3D __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 =3D _M_copy_aligned(__x.begin(), __x.end(), + begin()); + __x.clear(); + } + return *this; + } + +=20=20=20=20=20 + vector& + operator=3D(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } + + + + + + +=20=20=20=20=20 + 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)); } +# 948 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20=20=20 + void + assign(initializer_list __l) + { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()= ); } + + + [[__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 =3D + __gnu_cxx::__numeric_traits::__max + - int(_S_word_bit) + 1; + const size_type __asize + =3D _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); + return (__asize <=3D __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() =3D=3D end(); } + + [[__nodiscard__]] + reference + operator[](size_type __n) + { return begin()[__n]; } + + [[__nodiscard__]] + const_reference + operator[](size_type __n) const + { return begin()[__n]; } + + protected: +=20=20=20=20=20 + void + _M_range_check(size_type __n) const + { + if (__n >=3D this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which = is %zu) >=3D this->size() " "(which is %zu)") + + , + __n, this->size()); + } + + public: +=20=20=20=20=20 + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } + +=20=20=20=20=20 + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + +=20=20=20=20=20 + void + reserve(size_type __n) + { + if (__n > max_size()) + __throw_length_error(("vector::reserve")); + if (capacity() < __n) + _M_reallocate(__n); + } + + [[__nodiscard__]] + reference + front() + { return *begin(); } + + [[__nodiscard__]] + const_reference + front() const + { return *begin(); } + + [[__nodiscard__]] + reference + back() + { return *(end() - 1); } + + [[__nodiscard__]] + const_reference + back() const + { return *(end() - 1); } + +=20=20=20=20=20 + void + push_back(bool __x) + { + if (this->_M_impl._M_finish._M_p !=3D this->_M_impl._M_end_addr()) + *this->_M_impl._M_finish++ =3D __x; + else + _M_insert_aux(end(), __x); + } + +=20=20=20=20=20 + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propa= gate_on_container_swap::value || _M_get_Bit_allocator() =3D=3D __x._M_get_B= it_allocator())) __builtin_unreachable(); } 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()); + } + + +=20=20=20=20=20 + static void + swap(reference __x, reference __y) noexcept + { + bool __tmp =3D __x; + __x =3D __y; + __y =3D __tmp; + } + +=20=20=20=20=20 + iterator + + insert(const_iterator __position, const bool& __x) + + + + { + const difference_type __n =3D __position - begin(); + if (this->_M_impl._M_finish._M_p !=3D this->_M_impl._M_end_addr() + && __position =3D=3D end()) + *this->_M_impl._M_finish++ =3D __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 =3D __position - cbegin(); + _M_insert_range(__position._M_const_cast(), + __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1198 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __position, size_type __n, const bool& __x) + { + difference_type __offset =3D __position - cbegin(); + _M_fill_insert(__position._M_const_cast(), __n, __x); + return begin() + __offset; + } + + + + + + + +=20=20=20=20=20 + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } + + +=20=20=20=20=20 + void + pop_back() + { --this->_M_impl._M_finish; } + +=20=20=20=20=20 + iterator + + erase(const_iterator __position) + + + + { return _M_erase(__position._M_const_cast()); } + +=20=20=20=20=20 + iterator + + erase(const_iterator __first, const_iterator __last) + + + + { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } + +=20=20=20=20=20 + void + resize(size_type __new_size, bool __x =3D bool()) + { + if (__new_size < size()) + _M_erase_at_end(begin() + difference_type(__new_size)); + else + insert(end(), __new_size - size(), __x); + } + + +=20=20=20=20=20 + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + +=20=20=20=20=20 + void + flip() noexcept + { + _Bit_type * const __end =3D this->_M_impl._M_end_addr(); + for (_Bit_type * __p =3D this->_M_impl._M_start._M_p; __p !=3D __end; ++_= _p) + *__p =3D ~*__p; + } + +=20=20=20=20=20 + void + clear() noexcept + { _M_erase_at_end(begin()); } + + + template + + + reference + + + + emplace_back(_Args&&... __args) + { + push_back(bool(__args...)); + + return back(); + + } + + template + + iterator + emplace(const_iterator __pos, _Args&&... __args) + { return insert(__pos, bool(__args...)); } + + + protected: + +=20=20=20=20=20 + iterator + _M_copy_aligned(const_iterator __first, const_iterator __last, + iterator __result) + { + _Bit_type* __q =3D std::copy(__first._M_p, __last._M_p, __result._M_p); + return std::copy(const_iterator(__last._M_p, 0), __last, + iterator(__q, 0)); + } + +=20=20=20=20=20 + void + _M_initialize(size_type __n) + { + if (__n) + { + _Bit_pointer __q =3D this->_M_allocate(__n); + this->_M_impl._M_end_of_storage =3D __q + _S_nword(__n); + iterator __start =3D iterator(std::__addressof(*__q), 0); + this->_M_impl._M_start =3D __start; + this->_M_impl._M_finish =3D __start + difference_type(__n); + } + } + +=20=20=20=20=20 + void + _M_initialize_value(bool __x) noexcept + { + if (_Bit_type* __p =3D this->_M_impl._M_start._M_p) + __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); + } + +=20=20=20=20=20 + void + _M_reallocate(size_type __n); + + +=20=20=20=20=20 + bool + _M_shrink_to_fit(); +# 1359 "/usr/include/c++/13/bits/stl_bvector.h" 3 + template + + void + _M_initialize_range(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + for (; __first !=3D __last; ++__first) + push_back(*__first); + } + + template + + void + _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n =3D std::distance(__first, __last); + _M_initialize(__n); + std::copy(__first, __last, begin()); + } +# 1395 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20=20=20 + 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 =3D begin(); + for (; __first !=3D __last && __cur !=3D end(); ++__cur, (void)++__firs= t) + *__cur =3D *__first; + if (__first =3D=3D __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 =3D std::distance(__first, __last); + if (__len < size()) + _M_erase_at_end(std::copy(__first, __last, begin())); + else + { + _ForwardIterator __mid =3D __first; + std::advance(__mid, size()); + std::copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + } +# 1462 "/usr/include/c++/13/bits/stl_bvector.h" 3 +=20=20=20=20=20 + 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 !=3D __last; ++__first) + { + __pos =3D insert(__pos, *__first); + ++__pos; + } + } + + template + + void + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + +=20=20=20=20=20 + void + _M_insert_aux(iterator __position, bool __x); + +=20=20=20=20=20 + 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 =3D size() + std::max(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + +=20=20=20=20=20 + void + _M_erase_at_end(iterator __pos) + { this->_M_impl._M_finish =3D __pos; } + +=20=20=20=20=20 + iterator + _M_erase(iterator __pos); + +=20=20=20=20=20 + iterator + _M_erase(iterator __first, iterator __last); + + protected: + + + + + + + void data() =3D delete; + + + + }; + + + + +=20 + inline void + __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, + bool __x) noexcept + { + const _Bit_type __fmask =3D ~0ul << __first; + const _Bit_type __lmask =3D ~0ul >> (_S_word_bit - __last); + const _Bit_type __mask =3D __fmask & __lmask; + + if (__x) + *__v |=3D __mask; + else + *__v &=3D ~__mask; + } + + + __attribute__((__nonnull__)) +=20 + inline void + __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept + { +# 1558 "/usr/include/c++/13/bits/stl_bvector.h" 3 + __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); + } + + +=20 + inline void + __fill_a1(std::_Bit_iterator __first, + std::_Bit_iterator __last, const bool& __x) + { + if (__first._M_p !=3D __last._M_p) + { + _Bit_type* __first_p =3D __first._M_p; + if (__first._M_offset !=3D 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 !=3D 0) + __fill_bvector(__last._M_p, 0, __last._M_offset, __x); + } + else if (__first._M_offset !=3D __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; + }; + + + +} +# 68 "/usr/include/c++/13/vector" 2 3 + +# 1 "/usr/include/c++/13/bits/range_access.h" 1 3 +# 33 "/usr/include/c++/13/bits/range_access.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/range_access.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(const _Container& __cont) -> 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) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(const _Container& __cont) -> 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) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 261 "/usr/include/c++/13/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() =3D=3D 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(); } +# 370 "/usr/include/c++/13/bits/range_access.h" 3 + +} +# 70 "/usr/include/c++/13/vector" 2 3 + + +# 1 "/usr/include/c++/13/bits/vector.tcc" 1 3 +# 59 "/usr/include/c++/13/bits/vector.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template +=20=20=20 + 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 =3D size(); + pointer __tmp; + + if constexpr (_S_use_relocate()) + { + __tmp =3D this->_M_allocate(__n); + _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, + __tmp, _M_get_Tp_allocator()); + } + else + + { + __tmp =3D _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 =3D __tmp; + this->_M_impl._M_finish =3D __tmp + __old_size; + this->_M_impl._M_end_of_storage =3D this->_M_impl._M_start + __n; + } + } + + + template + template + +=20=20=20=20=20 + typename vector<_Tp, _Alloc>::reference + + + + vector<_Tp, _Alloc>:: + emplace_back(_Args&&... __args) + { + if (this->_M_impl._M_finish !=3D 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_insert(end(), std::forward<_Args>(__args)...); + + return back(); + + } + + + template +=20=20=20 + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + + insert(const_iterator __position, const value_type& __x) + + + + { + const size_type __n =3D __position - begin(); + if (this->_M_impl._M_finish !=3D this->_M_impl._M_end_of_storage) + { + do { if (std::__is_constant_evaluated() && !bool(__position !=3D const_= iterator())) __builtin_unreachable(); } while (false); + if (!(__position !=3D const_iterator())) + __builtin_unreachable(); + + if (__position =3D=3D end()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + ; + } + else + { + + const auto __pos =3D 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 +=20=20=20 + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __position) + { + if (__position + 1 !=3D 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 +=20=20=20 + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __first, iterator __last) + { + if (__first !=3D __last) + { + if (__last !=3D end()) + std::move(__last, end(), __first); + _M_erase_at_end(__first.base() + (end() - __last)); + } + return __first; + } + + template +=20=20=20 + vector<_Tp, _Alloc>& + vector<_Tp, _Alloc>:: + operator=3D(const vector<_Tp, _Alloc>& __x) + { + if (std::__addressof(__x) !=3D this) + { + ; + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() + && _M_get_Tp_allocator() !=3D __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 =3D nullptr; + this->_M_impl._M_finish =3D nullptr; + this->_M_impl._M_end_of_storage =3D nullptr; + } + std::__alloc_on_copy(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } + + const size_type __xlen =3D __x.size(); + if (__xlen > capacity()) + { + pointer __tmp =3D _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 =3D __tmp; + this->_M_impl._M_end_of_storage =3D this->_M_impl._M_start + __xlen; + } + else if (size() >=3D __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 =3D this->_M_impl._M_start + __xlen; + } + return *this; + } + + template +=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_fill_assign(size_t __n, const value_type& __val) + { + if (__n > capacity()) + { + vector __tmp(__n, __val, _M_get_Tp_allocator()); + __tmp._M_impl._M_swap_data(this->_M_impl); + } + else if (__n > size()) + { + std::fill(begin(), end(), __val); + const size_type __add =3D __n - size(); + ; + this->_M_impl._M_finish =3D + 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 +=20=20=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + pointer __cur(this->_M_impl._M_start); + for (; __first !=3D __last && __cur !=3D this->_M_impl._M_finish; + ++__cur, (void)++__first) + *__cur =3D *__first; + if (__first =3D=3D __last) + _M_erase_at_end(__cur); + else + _M_range_insert(end(), __first, __last, + std::__iterator_category(__first)); + } + + template + template +=20=20=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len =3D std::distance(__first, __last); + + if (__len > capacity()) + { + _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 =3D __tmp; + this->_M_impl._M_finish =3D this->_M_impl._M_start + __len; + this->_M_impl._M_end_of_storage =3D this->_M_impl._M_finish; + } + else if (size() >=3D __len) + _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); + else + { + _ForwardIterator __mid =3D __first; + std::advance(__mid, size()); + std::copy(__first, __mid, this->_M_impl._M_start); + const size_type __attribute__((__unused__)) __n =3D __len - size(); + ; + this->_M_impl._M_finish =3D + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } + } + + + template +=20=20=20 + auto + vector<_Tp, _Alloc>:: + _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator + { + const auto __n =3D __position - cbegin(); + if (this->_M_impl._M_finish !=3D this->_M_impl._M_end_of_storage) + if (__position =3D=3D 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 +=20=20=20=20=20 + auto + vector<_Tp, _Alloc>:: + _M_emplace_aux(const_iterator __position, _Args&&... __args) + -> iterator + { + const auto __n =3D __position - cbegin(); + if (this->_M_impl._M_finish !=3D this->_M_impl._M_end_of_storage) + if (__position =3D=3D 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 +=20=20=20=20=20 + 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, t= his->_M_impl._M_finish - 1) + + ; + + + + *__position =3D std::forward<_Arg>(__arg); + + } + + + template + template +=20=20=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_realloc_insert(iterator __position, _Args&&... __args) + + + + + + + { + const size_type __len =3D + _M_check_len(size_type(1), "vector::_M_realloc_insert"); + pointer __old_start =3D this->_M_impl._M_start; + pointer __old_finish =3D this->_M_impl._M_finish; + const size_type __elems_before =3D __position - begin(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + if (true) + { + + + + + + _Alloc_traits::construct(this->_M_impl, + __new_start + __elems_before, + + std::forward<_Args>(__args)...); + + + + __new_finish =3D pointer(); + + + if constexpr (_S_use_relocate()) + { + __new_finish =3D _S_relocate(__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish =3D _S_relocate(__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + else + + { + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + } + if (false) + { + if (!__new_finish) + _Alloc_traits::destroy(this->_M_impl, + __new_start + __elems_before); + else + std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + ; + } + + if constexpr (!_S_use_relocate()) + + 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 =3D __new_start; + this->_M_impl._M_finish =3D __new_finish; + this->_M_impl._M_end_of_storage =3D __new_start + __len; + } + + template +=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_fill_insert(iterator __position, size_type __n, const value_type& _= _x) + { + if (__n !=3D 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >=3D __n) + { + + + + _Temporary_value __tmp(this, __x); + value_type& __x_copy =3D __tmp._M_val(); + + const size_type __elems_after =3D 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 +=3D __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 =3D + 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 +=3D __elems_after; + ; + std::fill(__position.base(), __old_finish, __x_copy); + } + } + else + { + + + pointer __old_start =3D this->_M_impl._M_start; + pointer __old_finish =3D this->_M_impl._M_finish; + const pointer __pos =3D __position.base(); + + const size_type __len =3D + _M_check_len(__n, "vector::_M_fill_insert"); + const size_type __elems_before =3D __pos - __old_start; + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + if (true) + { + + std::__uninitialized_fill_n_a(__new_start + __elems_before, + __n, __x, + _M_get_Tp_allocator()); + __new_finish =3D pointer(); + + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__old_start, __pos, __new_start, _M_get_Tp_allocator()); + + __new_finish +=3D __n; + + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); + } + if (false) + { + 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); + ; + } + 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 =3D __new_start; + this->_M_impl._M_finish =3D __new_finish; + this->_M_impl._M_end_of_storage =3D __new_start + __len; + } + } + } + + + template +=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n !=3D 0) + { + const size_type __size =3D size(); + size_type __navail =3D 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 >=3D __n) + { + ; + this->_M_impl._M_finish =3D + std::__uninitialized_default_n_a(this->_M_impl._M_finish, + __n, _M_get_Tp_allocator()); + ; + } + else + { + + + pointer __old_start =3D this->_M_impl._M_start; + pointer __old_finish =3D this->_M_impl._M_finish; + + const size_type __len =3D + _M_check_len(__n, "vector::_M_default_append"); + pointer __new_start(this->_M_allocate(__len)); + if constexpr (_S_use_relocate()) + { + if (true) + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + } + if (false) + { + _M_deallocate(__new_start, __len); + ; + } + _S_relocate(__old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + else + { + pointer __destroy_from =3D pointer(); + if (true) + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + __destroy_from =3D __new_start + __size; + std::__uninitialized_move_if_noexcept_a( + __old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + if (false) + { + if (__destroy_from) + std::_Destroy(__destroy_from, __destroy_from + __n, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + ; + } + 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 =3D __new_start; + this->_M_impl._M_finish =3D __new_start + __size + __n; + this->_M_impl._M_end_of_storage =3D __new_start + __len; + } + } + } + + template +=20=20=20 + bool + vector<_Tp, _Alloc>:: + _M_shrink_to_fit() + { + if (capacity() =3D=3D size()) + return false; + ; + return std::__shrink_to_fit_aux::_S_do_it(*this); + } + + + template + template +=20=20=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + if (__pos =3D=3D end()) + { + for (; __first !=3D __last; ++__first) + insert(end(), *__first); + } + else if (__first !=3D __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 +=20=20=20=20=20 + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first !=3D __last) + { + const size_type __n =3D std::distance(__first, __last); + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >=3D __n) + { + const size_type __elems_after =3D 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 +=3D __n; + ; + std::move_backward(__position.base(), __old_finish - __n, __old_fini= sh) + ; + std::copy(__first, __last, __position); + } + else + { + _ForwardIterator __mid =3D __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 +=3D __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 +=3D __elems_after; + ; + std::copy(__first, __mid, __position); + } + } + else + { + + + + pointer __old_start =3D this->_M_impl._M_start; + pointer __old_finish =3D this->_M_impl._M_finish; + + const size_type __len =3D + _M_check_len(__n, "vector::_M_range_insert"); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + if (true) + { + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + __new_finish + =3D std::__uninitialized_copy_a(__first, __last, + __new_finish, + _M_get_Tp_allocator()); + __new_finish + =3D std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + if (false) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + ; + } + 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 =3D __new_start; + this->_M_impl._M_finish =3D __new_finish; + this->_M_impl._M_end_of_storage =3D __new_start + __len; + } + } + } + + + + template +=20=20=20 + void + vector:: + _M_reallocate(size_type __n) + { + _Bit_pointer __q =3D 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 =3D __start; + this->_M_impl._M_finish =3D __finish; + this->_M_impl._M_end_of_storage =3D __q + _S_nword(__n); + } + + template +=20=20=20 + void + vector:: + _M_fill_insert(iterator __position, size_type __n, bool __x) + { + if (__n =3D=3D 0) + return; + if (capacity() - size() >=3D __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 +=3D difference_type(__n); + } + else + { + const size_type __len =3D + _M_check_len(__n, "vector::_M_fill_insert"); + _Bit_pointer __q =3D this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i =3D _M_copy_aligned(begin(), __position, __start); + std::fill(__i, __i + difference_type(__n), __x); + iterator __finish =3D std::copy(__position, end(), + __i + difference_type(__n)); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage =3D __q + _S_nword(__len); + this->_M_impl._M_start =3D __start; + this->_M_impl._M_finish =3D __finish; + } + } + + template + template +=20=20=20=20=20 + void + vector:: + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first !=3D __last) + { + size_type __n =3D std::distance(__first, __last); + if (capacity() - size() >=3D __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + + difference_type(__n)); + std::copy(__first, __last, __position); + this->_M_impl._M_finish +=3D difference_type(__n); + } + else + { + const size_type __len =3D + _M_check_len(__n, "vector::_M_insert_range"); + _Bit_pointer __q =3D this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i =3D _M_copy_aligned(begin(), __position, __start); + __i =3D std::copy(__first, __last, __i); + iterator __finish =3D std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage =3D __q + _S_nword(__len); + this->_M_impl._M_start =3D __start; + this->_M_impl._M_finish =3D __finish; + } + } + } + + template +=20=20=20 + void + vector:: + _M_insert_aux(iterator __position, bool __x) + { + if (this->_M_impl._M_finish._M_p !=3D this->_M_impl._M_end_addr()) + { + std::copy_backward(__position, this->_M_impl._M_finish, + this->_M_impl._M_finish + 1); + *__position =3D __x; + ++this->_M_impl._M_finish; + } + else + { + const size_type __len =3D + _M_check_len(size_type(1), "vector::_M_insert_aux"); + _Bit_pointer __q =3D this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i =3D _M_copy_aligned(begin(), __position, __start); + *__i++ =3D __x; + iterator __finish =3D std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage =3D __q + _S_nword(__len); + this->_M_impl._M_start =3D __start; + this->_M_impl._M_finish =3D __finish; + } + } + + template +=20=20=20 + typename vector::iterator + vector:: + _M_erase(iterator __position) + { + if (__position + 1 !=3D end()) + std::copy(__position + 1, end(), __position); + --this->_M_impl._M_finish; + return __position; + } + + template +=20=20=20 + typename vector::iterator + vector:: + _M_erase(iterator __first, iterator __last) + { + if (__first !=3D __last) + _M_erase_at_end(std::copy(__last, end(), __first)); + return __first; + } + + + template +=20=20=20 + bool + vector:: + _M_shrink_to_fit() + { + if (capacity() - size() < int(_S_word_bit)) + return false; + if (true) + { + if (size_type __n =3D size()) + _M_reallocate(__n); + else + { + this->_M_deallocate(); + this->_M_impl._M_reset(); + } + return true; + } + if (false) + { return false; } + } + + + + +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + size_t + hash>:: + operator()(const std::vector& __b) const noexcept + { + size_t __hash =3D 0; + const size_t __words =3D __b.size() / _S_word_bit; + if (__words) + { + const size_t __clength =3D __words * sizeof(_Bit_type); + __hash =3D std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); + } + + const size_t __extrabits =3D __b.size() % _S_word_bit; + if (__extrabits) + { + _Bit_type __hiword =3D *__b._M_impl._M_finish._M_p; + __hiword &=3D ~((~static_cast<_Bit_type>(0)) << __extrabits); + + const size_t __clength + =3D (__extrabits + 8 - 1) / 8; + if (__words) + __hash =3D std::_Hash_impl::hash(&__hiword, __clength, __hash); + else + __hash =3D std::_Hash_impl::hash(&__hiword, __clength); + } + + return __hash; + } + + +} +# 73 "/usr/include/c++/13/vector" 2 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/memory_resource.h" 1 3 +# 33 "/usr/include/c++/13/bits/memory_resource.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/memory_resource.h" 3 + + + + +# 1 "/usr/include/c++/13/cstddef" 1 3 +# 42 "/usr/include/c++/13/cstddef" 3 +=20=20=20=20=20=20=20 +# 43 "/usr/include/c++/13/cstddef" 3 + + + + + + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 51 "/usr/include/c++/13/cstddef" 2 3 + +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 =3D byte; }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte;= }; + template<> struct __byte_operand { using __type =3D byte; }; + + + + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte= ; }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte; = }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D byte;= }; + template<> struct __byte_operand { using __type =3D byte; }; + template<> struct __byte_operand { using __type =3D = byte; }; + + template<> struct __byte_operand<__int128> + { using __type =3D byte; }; + template<> struct __byte_operand + { using __type =3D byte; }; +# 108 "/usr/include/c++/13/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 =3D 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<<=3D(byte& __b, _IntegerType __shift) noexcept + { return __b =3D __b << __shift; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator>>=3D(byte& __b, _IntegerType __shift) noexcept + { return __b =3D __b >> __shift; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator|=3D(byte& __l, byte __r) noexcept + { return __l =3D __l | __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator&=3D(byte& __l, byte __r) noexcept + { return __l =3D __l & __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator^=3D(byte& __l, byte __r) noexcept + { return __l =3D __l ^ __r; } + + template + [[nodiscard,__gnu__::__always_inline__]] + constexpr _IntegerType + to_integer(__byte_op_t<_IntegerType> __b) noexcept + { return _IntegerType(__b); } + + +} + +} +# 39 "/usr/include/c++/13/bits/memory_resource.h" 2 3 + + +# 1 "/usr/include/c++/13/bits/uses_allocator_args.h" 1 3 +# 33 "/usr/include/c++/13/bits/uses_allocator_args.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/uses_allocator_args.h" 3 +# 42 "/usr/include/c++/13/bits/memory_resource.h" 2 3 +# 50 "/usr/include/c++/13/bits/memory_resource.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace pmr +{ + + class memory_resource + { + static constexpr size_t _S_max_align =3D alignof(max_align_t); + + public: + memory_resource() =3D default; + memory_resource(const memory_resource&) =3D default; + virtual ~memory_resource(); + + memory_resource& operator=3D(const memory_resource&) =3D default; + + [[nodiscard]] + void* + allocate(size_t __bytes, size_t __alignment =3D _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 =3D _S_max_al= ign) + __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) =3D 0; + + virtual void + do_deallocate(void* __p, size_t __bytes, size_t __alignment) =3D 0; + + virtual bool + do_is_equal(const memory_resource& __other) const noexcept =3D 0; + }; + + [[nodiscard]] + inline bool + operator=3D=3D(const memory_resource& __a, const memory_resource& __b) n= oexcept + { return &__a =3D=3D &__b || __a.is_equal(__b); } + + + [[nodiscard]] + inline bool + operator!=3D(const memory_resource& __a, const memory_resource& __b) noe= xcept + { return !(__a =3D=3D __b); } + + + + template + class polymorphic_allocator + { + + + template + struct __not_pair { using type =3D void; }; + + template + struct __not_pair> { }; + + public: + using value_type =3D _Tp; + + polymorphic_allocator() noexcept + { + extern memory_resource* get_default_resource() noexcept + __attribute__((__returns_nonnull__)); + _M_resource =3D get_default_resource(); + } + + polymorphic_allocator(memory_resource* __r) noexcept + __attribute__((__nonnull__)) + : _M_resource(__r) + { ; } + + polymorphic_allocator(const polymorphic_allocator& __other) =3D defa= ult; + + template + polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept + : _M_resource(__x.resource()) + { } + + polymorphic_allocator& + operator=3D(const polymorphic_allocator&) =3D 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)); } +# 212 "/usr/include/c++/13/bits/memory_resource.h" 3 + template + __attribute__((__nonnull__)) + typename __not_pair<_Tp1>::type + construct(_Tp1* __p, _Args&&... __args) + { + + + using __use_tag + =3D 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 =3D + __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); + auto __y_tag =3D + __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))); + } +# 295 "/usr/include/c++/13/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=3D=3D(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return *__a.resource() =3D=3D *__b.resource(); } + + + [[nodiscard]] + friend bool + operator!=3D(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return !(__a =3D=3D __b); } + + + private: + + using __uses_alloc1_ =3D __uses_alloc1; + using __uses_alloc2_ =3D __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=3D=3D(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return *__a.resource() =3D=3D *__b.resource(); } + + + template + [[nodiscard]] + inline bool + operator!=3D(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return !(__a =3D=3D __b); } + + +} + + template struct allocator_traits; + + + template + struct allocator_traits> + { + + using allocator_type =3D pmr::polymorphic_allocator<_Tp>; + + + using value_type =3D _Tp; + + + using pointer =3D _Tp*; + + + using const_pointer =3D const _Tp*; + + + using void_pointer =3D void*; + + + using const_void_pointer =3D const void*; + + + using difference_type =3D std::ptrdiff_t; + + + using size_type =3D std::size_t; + + + + + + using propagate_on_container_copy_assignment =3D false_type; + using propagate_on_container_move_assignment =3D false_type; + using propagate_on_container_swap =3D false_type; + + static allocator_type + select_on_container_copy_construction(const allocator_type&) noexcept + { return allocator_type(); } + + + + using is_always_equal =3D false_type; + + template + using rebind_alloc =3D pmr::polymorphic_allocator<_Up>; + + template + using rebind_traits =3D allocator_traits>; +# 434 "/usr/include/c++/13/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 449 "/usr/include/c++/13/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer) + { return __a.allocate(__n); } +# 461 "/usr/include/c++/13/bits/memory_resource.h" 3 + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 476 "/usr/include/c++/13/bits/memory_resource.h" 3 + template + static void + construct(allocator_type& __a, _Up* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } +# 488 "/usr/include/c++/13/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); } + }; + + +} +# 81 "/usr/include/c++/13/vector" 2 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr { + template + using vector =3D std::vector<_Tp, polymorphic_allocator<_Tp>>; + } + + + + + + + + +} +# 23 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" 2 +# 36 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" + +# 36 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" +namespace hwy { + + + + + + +__attribute__((visibility("default"))) int64_t SupportedTargets(); +# 60 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" +__attribute__((visibility("default"))) void DisableTargets(int64_t disable= d_targets); + + + + + +__attribute__((visibility("default"))) void SetSupportedTargetsForTest(int= 64_t targets); + + + + + + +inline __attribute__((always_inline)) std::vector SupportedAndGen= eratedTargets() { + std::vector ret; + for (int64_t targets =3D SupportedTargets() & (((((1LL << 61) | 0 | 0 | = 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | (1LL << 37))) & ~((0) | ((0= | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0))))); targets !=3D 0; + targets =3D targets & (targets - 1)) { + int64_t current_target =3D targets & ~(targets - 1); + ret.push_back(current_target); + } + return ret; +} + + + +static inline __attribute__((unused)) const char* TargetName(int64_t targe= t) { + switch (target) { +# 136 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" + case (1LL << 37): + return "RVV"; + + + case (1LL << 61): + return "EMU128"; + case (1LL << 62): + return "SCALAR"; + + default: + return "Unknown"; + } +} +# 288 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/targets.h" +struct ChosenTarget { + public: + + + void Update(int64_t targets) { + + + StoreMask(((((targets) >> (38 + 1 - 9)) & ((1LL << 9) - 1)) << 1) | (1= LL << (9 + 1))); + } + + + + void DeInit() { StoreMask(1); } + + + + bool IsInitialized() const { return LoadMask() !=3D 1; } + + + + + + + size_t inline __attribute__((always_inline)) GetIndex() const { + return hwy::Num0BitsBelowLS1Bit_Nonzero64( + static_cast(LoadMask() & ((((((((((1LL << 61) | 0 | 0 | = 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | (1LL << 37))) & ~((0) | ((0= | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0)))))) >> (38 + 1 - 9)) & ((1LL << 9) - 1))= << 1) | (1LL << (9 + 1)) | 1LL))); + } + + private: + + + int64_t LoadMask() const { return mask_; } + void StoreMask(int64_t mask) { mask_ =3D mask; } + + int64_t mask_{1}; + + + + + + +}; + + +__attribute__((visibility("default"))) ChosenTarget& GetChosenTarget(); + +} +# 26 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" 2 + +namespace hwy { +# 252 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" +template +struct FunctionCache { + public: + typedef RetType(FunctionType)(Args...); +# 271 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" + template + static RetType ChooseAndCall(Args... args) { + ChosenTarget& chosen_target =3D GetChosenTarget(); + chosen_target.Update(SupportedTargets()); + return (table[chosen_target.GetIndex()])(args...); + } + +}; + + +template +FunctionCache DeduceFunctionCache(RetType (*)(Args...)) { + return FunctionCache(); +} +# 372 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" +} +# 412 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" 1 +# 19 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 20 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" 2 + +# 1 "/usr/include/c++/13/cmath" 1 3 +# 39 "/usr/include/c++/13/cmath" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cmath" 3 + + + + + + + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + + +# 34 "/usr/include/math.h" 3 4 +extern "C" { + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/math-vector.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/math-vector.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4 +# 28 "/usr/include/riscv64-linux-gnu/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/fp-fast.h" 1 3 4 +# 248 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD =3D + + 0, + FP_INT_DOWNWARD =3D + + 1, + FP_INT_TOWARDZERO =3D + + 2, + FP_INT_TONEARESTFROMZERO =3D + + 3, + FP_INT_TONEAREST =3D + + 4, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3= 4 +# 20 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (do= uble __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (do= uble __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (do= uble __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern doub= le __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (doub= le __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (doub= le __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (doub= le __x) noexcept (true); + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (do= uble __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (do= uble __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (do= uble __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept = (true); extern void __sincos (double __x, double *__sinx, double *__cosx) n= oexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (= double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (= double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (= double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (doub= le __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern = double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern d= ouble __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (doub= le __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (= double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern do= uble __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__= nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (= double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (= double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (= double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (dou= ble __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (do= uble __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (do= uble __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double= __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (dou= ble __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern doub= le __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (do= uble __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)= ); extern double __ceil (double __x) noexcept (true) __attribute__ ((__cons= t__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)= ); extern double __fabs (double __x) noexcept (true) __attribute__ ((__cons= t__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__= )); extern double __floor (double __x) noexcept (true) __attribute__ ((__co= nst__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double= __fmod (double __x, double __y) noexcept (true); +# 183 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double= __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __si= gnificand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribut= e__ ((__const__)); extern double __copysign (double __x, double __y) noexce= pt (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __na= n (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noe= xcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noe= xcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, d= ouble) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noe= xcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noe= xcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, d= ouble) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) = noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double= ) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (dou= ble) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (dou= ble) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (doubl= e) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern d= ouble __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (dou= ble __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern d= ouble __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); ex= tern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextd= own (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup = (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern d= ouble __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double = __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double = __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llog= b (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern d= ouble __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __near= byint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__= )); extern double __round (double __x) noexcept (true) __attribute__ ((__co= nst__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__= )); extern double __trunc (double __x) noexcept (true) __attribute__ ((__co= nst__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true);= extern double __remquo (double __x, double __y, int *__quo) noexcept (true= ); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrin= t (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long= int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lro= und (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long lon= g int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double= __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ = ((__const__)); extern double __fmax (double __x, double __y) noexcept (true= ) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ = ((__const__)); extern double __fmin (double __x, double __y) noexcept (true= ) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); ex= tern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__con= st__)); extern double __roundeven (double __x) noexcept (true) __attribute_= _ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) n= oexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsign= ed int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width)= noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, un= signed int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) = noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsi= gned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width= ) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, = unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute= __ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept= (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute= __ ((__const__)); extern double __fminmag (double __x, double __y) noexcept= (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribut= e__ ((__const__)); extern double __fmaximum (double __x, double __y) noexce= pt (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribut= e__ ((__const__)); extern double __fminimum (double __x, double __y) noexce= pt (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attr= ibute__ ((__const__)); extern double __fmaximum_num (double __x, double __y= ) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attr= ibute__ ((__const__)); extern double __fminimum_num (double __x, double __y= ) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attr= ibute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y= ) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attr= ibute__ ((__const__)); extern double __fminimum_mag (double __x, double __y= ) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __= attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, do= uble __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __= attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, do= uble __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (tru= e) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (= true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern doubl= e __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern doubl= e __scalb (double __x, double __n) noexcept (true); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3= 4 +# 20 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (flo= at __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (flo= at __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (flo= at __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float = __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float= __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float= __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float= __x) noexcept (true); + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (flo= at __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (flo= at __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (flo= at __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (t= rue); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexc= ept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (f= loat __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (f= loat __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (f= loat __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float= __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern f= loat __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern fl= oat __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float= __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (f= loat __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern floa= t __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonn= ull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (f= loat __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (f= loat __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (f= loat __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (floa= t __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (flo= at __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (flo= at __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __= powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (floa= t __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float = __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (flo= at __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__))= ; extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const_= _)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__))= ; extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const_= _)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)= ); extern float __floorf (float __x) noexcept (true) __attribute__ ((__cons= t__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __= fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __= dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __sign= ificandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute_= _ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (= true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nan= f (const char *__tagb) noexcept (true); +# 213 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexc= ept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexc= ept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, fl= oat) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexc= ept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexc= ept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, fl= oat) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) no= except (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) = noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (floa= t) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (floa= t) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float)= noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern fl= oat __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (floa= t __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern flo= at __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); ext= ern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdow= nf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (= float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern flo= at __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __= scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float = __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llog= bf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern fl= oat __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearby= intf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)= ); extern float __roundf (float __x) noexcept (true) __attribute__ ((__cons= t__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)= ); extern float __truncf (float __x) noexcept (true) __attribute__ ((__cons= t__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); e= xtern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrin= tf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long= int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lro= undf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long lon= g int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __= fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((= __const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __= attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((= __const__)); extern float __fminf (float __x, float __y) noexcept (true) __= attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); exter= n float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__cons= t__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ = ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) n= oexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsign= ed int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width)= noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, un= signed int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) = noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsi= gned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width= ) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, = unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__= ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (tr= ue) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__= ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (tr= ue) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute_= _ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (= true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute_= _ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (= true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attrib= ute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) no= except (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attrib= ute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) no= except (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attrib= ute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) no= except (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attrib= ute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) no= except (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __at= tribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float= __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __at= tribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float= __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (t= rue) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float = __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float _= _scalbf (float __x, float __n) noexcept (true); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3= 4 +# 20 "/usr/include/riscv64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long d= ouble __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long d= ouble __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long d= ouble __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (tr= ue); extern long double __atan2l (long double __y, long double __x) noexcep= t (true); + + + extern long double cosl (long double __x) noexcept (true); extern long do= uble __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long do= uble __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long do= uble __tanl (long double __x) noexcept (true); + + + + + extern long double coshl (long double __x) noexcept (true); extern long d= ouble __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long d= ouble __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long d= ouble __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *_= _cosx) noexcept (true); extern void __sincosl (long double __x, long double= *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long = double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long = double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long = double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long do= uble __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (tru= e); extern long double __frexpl (long double __x, int *__exponent) noexcept= (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true= ); extern long double __ldexpl (long double __x, int __exponent) noexcept (= true); + + + extern long double logl (long double __x) noexcept (true); extern long do= uble __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long = double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (= true); extern long double __modfl (long double __x, long double *__iptr) no= except (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long = double __exp10l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long = double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long = double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long do= uble __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long d= ouble __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long d= ouble __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true= ); extern long double __powl (long double __x, long double __y) noexcept (t= rue); + + +extern long double sqrtl (long double __x) noexcept (true); extern long do= uble __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (tr= ue); extern long double __hypotl (long double __x, long double __y) noexcep= t (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long d= ouble __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ (= (__const__)); extern long double __ceill (long double __x) noexcept (true) = __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ (= (__const__)); extern long double __fabsl (long double __x) noexcept (true) = __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ = ((__const__)); extern long double __floorl (long double __x) noexcept (true= ) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true= ); extern long double __fmodl (long double __x, long double __y) noexcept (= true); +# 177 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true= ); extern long double __dreml (long double __x, long double __y) noexcept (= true); + + + +extern long double significandl (long double __x) noexcept (true); extern = long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (= true) __attribute__ ((__const__)); extern long double __copysignl (long dou= ble __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long = double __nanl (const char *__tagb) noexcept (true); +# 213 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double _= _j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double _= _j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long dou= ble __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double _= _y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double _= _y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long dou= ble __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double= __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long doubl= e __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long doub= le __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long doub= le __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long doubl= e __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true= ); extern long double __lgammal_r (long double, int *__signgamp) noexcept (= true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long do= uble __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept = (true); extern long double __nextafterl (long double __x, long double __y) = noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept= (true); extern long double __nexttowardl (long double __x, long double __y= ) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern lon= g double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long = double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept = (true); extern long double __remainderl (long double __x, long double __y) = noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); ext= ern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (= long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int = __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true= ); extern long double __scalblnl (long double __x, long int __n) noexcept (= true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern lo= ng double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ = ((__const__)); extern long double __roundl (long double __x) noexcept (true= ) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ = ((__const__)); extern long double __truncl (long double __x) noexcept (true= ) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) = noexcept (true); extern long double __remquol (long double __x, long double= __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int = __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern lon= g long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int= __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern lo= ng long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true= ); extern long double __fdiml (long double __x, long double __y) noexcept (= true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true= ) __attribute__ ((__const__)); extern long double __fmaxl (long double __x,= long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true= ) __attribute__ ((__const__)); extern long double __fminl (long double __x,= long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z= ) noexcept (true); extern long double __fmal (long double __x, long double = __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribut= e__ ((__const__)); extern long double __roundevenl (long double __x) noexce= pt (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __wi= dth) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __r= ound, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __= width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int= __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __w= idth) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int _= _width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, i= nt __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexc= ept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (t= rue) __attribute__ ((__const__)); extern long double __fmaxmagl (long doubl= e __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (t= rue) __attribute__ ((__const__)); extern long double __fminmagl (long doubl= e __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (= true) __attribute__ ((__const__)); extern long double __fmaximuml (long dou= ble __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (= true) __attribute__ ((__const__)); extern long double __fminimuml (long dou= ble __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexce= pt (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (= long double __x, long double __y) noexcept (true) __attribute__ ((__const__= )); + + +extern long double fminimum_numl (long double __x, long double __y) noexce= pt (true) __attribute__ ((__const__)); extern long double __fminimum_numl (= long double __x, long double __y) noexcept (true) __attribute__ ((__const__= )); + + +extern long double fmaximum_magl (long double __x, long double __y) noexce= pt (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (= long double __x, long double __y) noexcept (true) __attribute__ ((__const__= )); + + +extern long double fminimum_magl (long double __x, long double __y) noexce= pt (true) __attribute__ ((__const__)); extern long double __fminimum_magl (= long double __x, long double __y) noexcept (true) __attribute__ ((__const__= )); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) no= except (true) __attribute__ ((__const__)); extern long double __fmaximum_ma= g_numl (long double __x, long double __y) noexcept (true) __attribute__ ((_= _const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) no= except (true) __attribute__ ((__const__)); extern long double __fminimum_ma= g_numl (long double __x, long double __y) noexcept (true) __attribute__ ((_= _const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) no= except (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y)= noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); e= xtern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept = (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexce= pt (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (tru= e); extern long double __scalbl (long double __x, long double __n) noexcept= (true); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 _= _acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 _= _asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 _= _atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); ex= tern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __= cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __= sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __= tanf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 _= _coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 _= _sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 _= _tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) = noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _= Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 = __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 = __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 = __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __= expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); = extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); e= xtern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __= logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 = __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); = extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) = __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 = __exp10f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 = __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 = __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __= logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 _= _exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 _= _log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); exte= rn _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __= sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); ex= tern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 _= _cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__c= onst__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attrib= ute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__c= onst__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attrib= ute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attr= ibute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); exte= rn _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 198 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _F= loat32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float= 32 __nanf32 (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 = (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 = (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __j= nf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 = (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 = (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __y= nf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff= 32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erf= cf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lg= ammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tg= ammaf32 (_Float32) noexcept (true); +# 252 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); e= xtern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __= rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true);= extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true= ); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float3= 2 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 = __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true);= extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true= ); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern = _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 = (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int _= _llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); e= xtern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float= 32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attr= ibute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attr= ibute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcep= t (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__q= uo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int _= _lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long= long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int = __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern lon= g long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); exte= rn _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __att= ribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 _= _y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __att= ribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 _= _y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept= (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z= ) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ = ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true= ) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __wid= th) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __rou= nd, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __w= idth) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __wi= dth) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __r= ound, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __= width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int= __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept = (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __= attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Flo= at32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __= attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Flo= at32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _F= loat32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _F= loat32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32= __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32= __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32= __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32= __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (= _Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (= _Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexce= pt (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noe= xcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); exter= n _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (tru= e); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (= true); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 _= _acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 _= _asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 _= _atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); ex= tern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __= cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __= sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __= tanf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 _= _coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 _= _sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 _= _tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) = noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _= Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 = __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 = __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 = __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __= expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); = extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); e= xtern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __= logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 = __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); = extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) = __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 = __exp10f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 = __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 = __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __= logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 _= _exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 _= _log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); exte= rn _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __= sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); ex= tern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 _= _cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__c= onst__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attrib= ute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__c= onst__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attrib= ute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attr= ibute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); exte= rn _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 198 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _F= loat64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float= 64 __nanf64 (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 = (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 = (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __j= nf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 = (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 = (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __y= nf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff= 64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erf= cf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lg= ammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tg= ammaf64 (_Float64) noexcept (true); +# 252 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); e= xtern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __= rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true);= extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true= ); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float6= 4 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 = __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true);= extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true= ); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern = _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 = (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int _= _llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); e= xtern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float= 64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attr= ibute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__= const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attr= ibute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcep= t (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__q= uo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int _= _lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long= long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int = __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern lon= g long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); exte= rn _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __att= ribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 _= _y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __att= ribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 _= _y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept= (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z= ) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ = ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true= ) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __wid= th) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __rou= nd, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __w= idth) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __wi= dth) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __r= ound, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __= width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int= __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept = (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __= attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Flo= at64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __= attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Flo= at64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _F= loat64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _F= loat64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64= __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64= __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64= __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64= __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (= _Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (= _Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexce= pt (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noe= xcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); exter= n _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (tru= e); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (= true); +# 468 "/usr/include/math.h" 2 3 4 +# 484 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true)= ; extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (tru= e); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __tanf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__co= sx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__= sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float= 128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float= 128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float= 128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true= ); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (= true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true)= ; extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (tr= ue); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float= 128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (tru= e); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept= (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float= 128 __exp10f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float= 128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float= 128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float1= 28 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float1= 28 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); = extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true)= ; extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (tru= e); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float1= 28 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((= __const__)); extern _Float128 __ceilf128 (_Float128 __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((= __const__)); extern _Float128 __fabsf128 (_Float128 __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ (= (__const__)); extern _Float128 __floorf128 (_Float128 __x) noexcept (true) = __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); = extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 198 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 = __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Flo= at128 __nanf128 (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0= f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1= f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128= __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0= f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1= f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128= __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __= erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 _= _erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 = __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 = __tgammaf128 (_Float128) noexcept (true); +# 252 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true)= ; extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (tr= ue); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float12= 8 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (tr= ue); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexce= pt (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Flo= at128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float= 128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (tr= ue); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexce= pt (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); exte= rn _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf1= 28 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int= __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true)= ; extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (tr= ue); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Fl= oat128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ (= (__const__)); extern _Float128 __roundf128 (_Float128 __x) noexcept (true) = __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ (= (__const__)); extern _Float128 __truncf128 (_Float128 __x) noexcept (true) = __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noe= xcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, = int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int= __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern lo= ng long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long in= t __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern l= ong long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); = extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Fl= oat128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Fl= oat128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noe= xcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Fl= oat128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute= __ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) noexcept= (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __w= idth) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int _= _width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, i= nt __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __= width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int= __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int = __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x,= int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexce= pt (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __= x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __= x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float128 __fmaximumf128 (_Float128 = __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float128 __fminimumf128 (_Float128 = __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_numf128 (_F= loat128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float128 __fminimum_numf128 (_F= loat128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_magf128 (_F= loat128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept = (true) __attribute__ ((__const__)); extern _Float128 __fminimum_magf128 (_F= loat128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_mag_num= f128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const= __)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float128 __fminimum_mag_num= f128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const= __)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noe= xcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) = noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); ex= tern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (= true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcep= t (true); +# 485 "/usr/include/math.h" 2 3 4 +# 501 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true)= ; extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (tru= e); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32= x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32= x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32= x __tanf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__co= sx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__= sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float= 32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float= 32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float= 32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32= x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true= ); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (= true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true)= ; extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (tr= ue); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32= x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float= 32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (tru= e); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept= (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float= 32x __exp10f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float= 32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float= 32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32= x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float3= 2x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float3= 2x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); = extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32= x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true)= ; extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (tru= e); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float3= 2x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((= __const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((= __const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) = __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); = extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 198 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x = __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Flo= at32x __nanf32x (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0= f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1= f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x= __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0= f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1= f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x= __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __= erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x _= _erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x = __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x = __tgammaf32x (_Float32x) noexcept (true); +# 252 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true)= ; extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (tr= ue); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32= x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (tr= ue); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexce= pt (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Flo= at32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float= 32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (tr= ue); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexce= pt (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); exte= rn _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf3= 2x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int= __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true)= ; extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (tr= ue); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Fl= oat32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) = __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) = __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noe= xcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, = int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int= __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern lo= ng long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long in= t __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern l= ong long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); = extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Fl= oat32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Fl= oat32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noe= xcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Fl= oat32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute= __ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept= (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __w= idth) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int _= _width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, i= nt __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __= width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int= __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int = __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x,= int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexce= pt (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __= x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __= x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x = __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x = __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_F= loat32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_F= loat32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_F= loat32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_F= loat32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_num= f32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const= __)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_num= f32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const= __)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noe= xcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) = noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); ex= tern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (= true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcep= t (true); +# 502 "/usr/include/math.h" 2 3 4 +# 518 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true)= ; extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (tru= e); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64= x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64= x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64= x __tanf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__co= sx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__= sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float= 64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float= 64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float= 64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64= x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true= ); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (= true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true)= ; extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (tr= ue); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64= x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float= 64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (tru= e); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept= (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float= 64x __exp10f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float= 64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float= 64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64= x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float6= 4x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float6= 4x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); = extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64= x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true)= ; extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (tru= e); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float6= 4x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((= __const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((= __const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __= attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) = __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); = extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 198 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x = __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Flo= at64x __nanf64x (const char *__tagb) noexcept (true); +# 220 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0= f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1= f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x= __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0= f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1= f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x= __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __= erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x _= _erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x = __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x = __tgammaf64x (_Float64x) noexcept (true); +# 252 "/usr/include/riscv64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true)= ; extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (tr= ue); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64= x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (tr= ue); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexce= pt (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Flo= at64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float= 64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (tr= ue); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexce= pt (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); exte= rn _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf6= 4x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int= __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true)= ; extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (tr= ue); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Fl= oat64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) = __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ (= (__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) = __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noe= xcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, = int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int= __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern lo= ng long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long in= t __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern l= ong long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); = extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Fl= oat64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) _= _attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Fl= oat64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noe= xcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Fl= oat64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute= __ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept= (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __w= idth) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int _= _round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int _= _width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, i= nt __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __= width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int= __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int = __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x,= int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexce= pt (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __= x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true= ) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __= x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x = __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (tru= e) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x = __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_F= loat64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_F= loat64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_F= loat64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept = (true) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_F= loat64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_num= f64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const= __)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexc= ept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_num= f64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const= __)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noe= xcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) = noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); ex= tern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (= true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcep= t (true); +# 519 "/usr/include/math.h" 2 3 4 +# 566 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 567 "/usr/include/math.h" 2 3 4 +# 587 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noe= xcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 588 "/usr/include/math.h" 2 3 4 +# 616 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) no= except (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 617 "/usr/include/math.h" 2 3 4 +# 697 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) n= oexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 698 "/usr/include/math.h" 2 3 4 +# 707 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexc= ept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 708 "/usr/include/math.h" 2 3 4 +# 717 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) n= oexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 718 "/usr/include/math.h" 2 3 4 +# 727 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) n= oexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 728 "/usr/include/math.h" 2 3 4 +# 747 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noe= xcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 748 "/usr/include/math.h" 2 3 4 +# 757 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true= ); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true= ); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z)= noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true= ); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true= ); +# 758 "/usr/include/math.h" 2 3 4 +# 767 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z)= noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true= ); +# 768 "/usr/include/math.h" 2 3 4 +# 787 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) n= oexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 788 "/usr/include/math.h" 2 3 4 +# 797 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) n= oexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 798 "/usr/include/math.h" 2 3 4 +# 817 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z)= noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true= ); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true= ); +# 818 "/usr/include/math.h" 2 3 4 +# 854 "/usr/include/math.h" 3 4 +extern int signgam; +# 934 "/usr/include/math.h" 3 4 +enum + { + FP_NAN =3D + + 0, + FP_INFINITE =3D + + 1, + FP_ZERO =3D + + 2, + FP_SUBNORMAL =3D + + 3, + FP_NORMAL =3D + + 4 + }; +# 1054 "/usr/include/math.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/iscanonical.h" 1 3 4 +# 1055 "/usr/include/math.h" 2 3 4 +# 1066 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + + + +} +# 1097 "/usr/include/math.h" 3 4 +extern "C++" { +# 1128 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val =3D=3D 0; +} + +} +# 1363 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template<> struct __iseqsig_type<_Float32> +{ + static int __call (_Float32 __x, _Float32 __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64> +{ + static int __call (_Float64 __x, _Float64 __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + + + + return __iseqsigl (__x, __y); + + } +}; + + + +template<> struct __iseqsig_type<_Float32x> +{ + static int __call (_Float32x __x, _Float32x __y) throw () + { + return __iseqsig (__x, __y); + } +}; + + + +template<> struct __iseqsig_type<_Float64x> +{ + static int __call (_Float64x __x, _Float64x __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 48 "/usr/include/c++/13/cmath" 2 3 + +# 1 "/usr/include/c++/13/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/13/bits/std_abs.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/std_abs.h" 3 + + + + +# 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/13/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__ ((__nonnu= ll__ (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 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))); +# 233 "/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))); +# 275 "/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 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))); +# 317 "/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))); +# 361 "/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 i= nt +__attribute__ ((__leaf__)) atoll (const char *__nptr) noexcept (true) +{ + return strtoll (__nptr, (char **) __null, 10); +} +# 386 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) __attribute__ ((__warn_un= used_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 __ino_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 __off_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/13/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 +# 24 "/usr/include/riscv64-linux-gnu/bits/select2.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"))); +# 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; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/riscv64-linux-gnu/sys/types.h" 3 4 +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 +} +# 396 "/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__ ((__non= null__ (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) __at= tribute__ ((__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) __attr= ibute__ ((__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__ ((__non= null__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__non= null__ (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__ ((__no= nnull__ (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__ ((__mall= oc__)) + __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_re= sult__)); + +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/13/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 588 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__mall= oc__)) + __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_re= sult__)); + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __s= ize) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_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_re= sult__)); + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +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))); +# 630 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__ar= g) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn= __)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__no= return__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noretur= n__)); + + + + +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__ ((__w= arn_unused_result__)); + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnu= ll__ (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); +# 695 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__n= onnull__ (1))); +# 708 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __= attribute__ ((__warn_unused_result__)); +# 718 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) = __attribute__ ((__warn_unused_result__)); +# 730 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__= nonnull__ (1))) __attribute__ ((__warn_unused_result__)); +# 740 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_resul= t__)); +# 751 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__= nonnull__ (1))) __attribute__ ((__warn_unused_result__)); +# 762 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonn= ull__ (1))) __attribute__ ((__warn_unused_result__)); +# 772 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__no= nnull__ (1))) __attribute__ ((__warn_unused_result__)); +# 782 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_resul= t__)); +# 794 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_resul= t__)); +# 804 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) __attribute__ ((__warn_unused_re= sult__)); + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__m= alloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) __attribute__ ((__wa= rn_unused_result__)); +# 821 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) __attribute__ ((__wa= rn_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 __s= ize, + __compar_fn_t __compar) +{ + size_t __l, __u, __idx; + const void *__p; + int __comparison; + + __l =3D 0; + __u =3D __nmemb; + while (__l < __u) + { + __idx =3D (__l + __u) / 2; + __p =3D (const void *) (((const char *) __base) + (__idx * __size)); + __comparison =3D (*__compar) (__key, __p); + if (__comparison < 0) + __u =3D __idx; + else if (__comparison > 0) + __l =3D __idx + 1; + else + { + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-qual" + + return (void *) __p; + +#pragma GCC diagnostic pop + + } + } + + return __null; +} +# 847 "/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__)) __att= ribute__ ((__warn_unused_result__)); +extern long int labs (long int __x) noexcept (true) __attribute__ ((__cons= t__)) __attribute__ ((__warn_unused_result__)); + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_un= used_result__)); + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_un= used_result__)); +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_un= used_result__)); + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) __attribute__ ((__warn_un= used_result__)); +# 893 "/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__ ((__w= arn_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__ ((__w= arn_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__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ = ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)); +# 980 "/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_unu= sed_result__)); + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__a= ccess__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1036 "/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); +} +# 1037 "/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_unuse= d_result__)); +extern char *__realpath_alias (const char *__restrict __name, char *__rest= rict __resolved) noexcept (true) __asm__ ("" "realpath") + + __attribute__ ((__warn_un= used_result__)); +extern char *__realpath_chk_warn (const char *__restrict __name, char *__r= estrict __resolved, size_t __resolvedlen) noexcept (true) __asm__ ("" "__re= alpath_chk") + + + __attribute__ ((__warn_unu= sed_result__)) + __attribute__((__warning__ ("second argument of realpath must be eith= er NULL or at " "least PATH_MAX bytes long buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) char * +__attribute__ ((__leaf__)) realpath (const char *__restrict __name, char *= __restrict __resolved) noexcept (true) +{ + size_t sz =3D __builtin_object_size (__resolved, 2 > 1); + + if (sz =3D=3D (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) noex= cept (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, s= ize_t __nreal) noexcept (true) __asm__ ("" "__ptsname_r_chk") + + + __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsnam= e_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 __bufl= en) noexcept (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_= p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned = int) (__buflen)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (= char))))) && (((long unsigned int) (__buflen)) <=3D ((__builtin_object_size= (__buf, 2 > 1))) / ((sizeof (char)))))) ? __ptsname_r_alias (__fd, __buf, = __buflen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__bui= ltin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((= long unsigned int) (__buflen)) <=3D (__builtin_object_size (__buf, 2 > 1)) = / (sizeof (char)))) && !(((long unsigned int) (__buflen)) <=3D (__builtin_o= bject_size (__buf, 2 > 1)) / (sizeof (char)))) ? __ptsname_r_chk_warn (__fd= , __buf, __buflen, __builtin_object_size (__buf, 2 > 1)) : __ptsname_r_chk = (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 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) __a= sm__ ("" "wctomb") + __attribute__ ((__warn_unused_result__)); + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) int +__attribute__ ((__leaf__)) wctomb (char *__s, wchar_t __wchar) noexcept (t= rue) +{ + + + + + + + + if (__builtin_object_size (__s, 2 > 1) !=3D (size_t) -1 + && 16 > __builtin_object_size (__s, 2 > 1)) + return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 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 *__r= estrict __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 =3D=3D __null) && __dst =3D=3D __null) + return __mbstowcs_nulldst (__dst, __src, __len); + else + return (((__builtin_constant_p (__builtin_object_size (__dst, 2 > 1)) = && (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) ||= (((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (_= _len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__le= n)) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (wchar_t))))) = && (((long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > = 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= )) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (wchar_t)))) && !(= ((long unsigned int) (__len)) <=3D (__builtin_object_size (__dst, 2 > 1)) /= (sizeof (wchar_t)))) ? __mbstowcs_chk_warn (__dst, __src, __len, (__builti= n_object_size (__dst, 2 > 1)) / (sizeof (wchar_t))) : __mbstowcs_chk (__dst= , __src, __len, (__builtin_object_size (__dst, 2 > 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__ ((__ac= cess__ (__read_only__, 2))); +extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__r= estrict __src, size_t __len) noexcept (true) __asm__ ("" "wcstombs") + + + + __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__ac= cess__ (__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_object_size (__dst, 2 > 1)) &&= (__builtin_object_size (__dst, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__dst, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__dst, 2 > 1))) = / ((sizeof (char)))))) ? __wcstombs_alias (__dst, __src, __len) : ((((__typ= eof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && = (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <=3D = (__builtin_object_size (__dst, 2 > 1)) / (sizeof (char)))) && !(((long unsi= gned int) (__len)) <=3D (__builtin_object_size (__dst, 2 > 1)) / (sizeof (c= har)))) ? __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (= __dst, 2 > 1)) : __wcstombs_chk (__dst, __src, __len, __builtin_object_size= (__dst, 2 > 1)))) + + ; +} +# 1041 "/usr/include/stdlib.h" 2 3 4 + + + + + + + +} +# 39 "/usr/include/c++/13/bits/std_abs.h" 2 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); } +# 70 "/usr/include/c++/13/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 >=3D 0 ? __x : -__x; } +# 141 "/usr/include/c++/13/bits/std_abs.h" 3 + +} +} +# 50 "/usr/include/c++/13/cmath" 2 3 +# 79 "/usr/include/c++/13/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 414 "/usr/include/c++/13/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1096 "/usr/include/c++/13/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x !=3D 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp __x) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x !=3D 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1881 "/usr/include/c++/13/cmath" 3 + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __typ= e; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3567 "/usr/include/c++/13/cmath" 3 + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x =3D std::abs(__x); + __y =3D std::abs(__y); + __z =3D std::abs(__z); + if (_Tp __a =3D __x < __y ? __y < __z ? __z : __y : __x < __z ? __z = : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type =3D __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3712 "/usr/include/c++/13/cmath" 3 + +} + + +# 1 "/usr/include/c++/13/bits/specfun.h" 1 3 +# 44 "/usr/include/c++/13/bits/specfun.h" 3 +# 1 "/usr/include/c++/13/limits" 1 3 +# 40 "/usr/include/c++/13/limits" 3 +=20=20=20=20=20=20=20 +# 41 "/usr/include/c++/13/limits" 3 +# 158 "/usr/include/c++/13/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate =3D -1, + round_toward_zero =3D 0, + round_to_nearest =3D 1, + round_toward_infinity =3D 2, + round_toward_neg_infinity =3D 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate =3D -1, + + denorm_absent =3D 0, + + denorm_present =3D 1 + }; +# 202 "/usr/include/c++/13/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized =3D false; + + + + + static constexpr int digits =3D 0; + + + static constexpr int digits10 =3D 0; + + + + + static constexpr int max_digits10 =3D 0; + + + + static constexpr bool is_signed =3D false; + + + static constexpr bool is_integer =3D false; + + + + + static constexpr bool is_exact =3D false; + + + + static constexpr int radix =3D 0; + + + + static constexpr int min_exponent =3D 0; + + + + static constexpr int min_exponent10 =3D 0; + + + + + static constexpr int max_exponent =3D 0; + + + + static constexpr int max_exponent10 =3D 0; + + + static constexpr bool has_infinity =3D false; + + + + static constexpr bool has_quiet_NaN =3D false; + + + + static constexpr bool has_signaling_NaN =3D false; + + + static constexpr float_denorm_style has_denorm =3D denorm_absent; + + + + static constexpr bool has_denorm_loss =3D false; + + + + static constexpr bool is_iec559 =3D false; + + + + + static constexpr bool is_bounded =3D false; +# 288 "/usr/include/c++/13/limits" 3 + static constexpr bool is_modulo =3D false; + + + static constexpr bool traps =3D false; + + + static constexpr bool tinyness_before =3D false; + + + + + static constexpr float_round_style round_style =3D + round_toward_zero; + }; +# 311 "/usr/include/c++/13/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> { }; +# 383 "/usr/include/c++/13/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D 1; + static constexpr int digits10 =3D 0; + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + + + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D (sizeof(char) * 8 - ((char)(-1) < 0)= ); + static constexpr int digits10 =3D ((sizeof(char) * 8 - ((char)(-1) <= 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D ((char)(-1) < 0); + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D !is_signed; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D (sizeof(signed char) * 8 - ((signed = char)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2= 136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L= / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D true; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 << ((s= izeof(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 =3D (sizeof(wchar_t) * 8 - ((wchar_t)(-1= ) < 0)); + static constexpr int digits10 + =3D ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D ((wchar_t)(-1) < 0); + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D !is_signed; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; +# 796 "/usr/include/c++/13/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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) : ~(cha= r16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits =3D (sizeof(char16_t) * 8 - ((char16_t)(= -1) < 0)); + static constexpr int digits10 =3D ((sizeof(char16_t) * 8 - ((char16_= t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 =3D 0; + static constexpr bool is_signed =3D ((char16_t)(-1) < 0); + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D !is_signed; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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) : ~(cha= r32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits =3D (sizeof(char32_t) * 8 - ((char32_t)(= -1) < 0)); + static constexpr int digits10 =3D ((sizeof(char32_t) * 8 - ((char32_= t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 =3D 0; + static constexpr bool is_signed =3D ((char32_t)(-1) < 0); + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D !is_signed; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style =3D round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D (sizeof(short) * 8 - ((short)(-1) < = 0)); + static constexpr int digits10 =3D ((sizeof(short) * 8 - ((short)(-1)= < 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 64= 3L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D true; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 =3D ((sizeof(int) * 8 - ((int)(-1) < 0= )) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L /= 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D true; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 =3D (sizeof(long) * 8 - ((long)(-1) < 0)= ); + static constexpr int digits10 =3D ((sizeof(long) * 8 - ((long)(-1) <= 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L= / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D true; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + =3D ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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 + =3D (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0= )); + static constexpr int digits10 + =3D ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < = 0)) * 643L / 2136); + + static constexpr int max_digits10 =3D 0; + + static constexpr bool is_signed =3D false; + static constexpr bool is_integer =3D true; + static constexpr bool is_exact =3D true; + static constexpr int radix =3D 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 =3D 0; + static constexpr int min_exponent10 =3D 0; + static constexpr int max_exponent =3D 0; + static constexpr int max_exponent10 =3D 0; + + static constexpr bool has_infinity =3D false; + static constexpr bool has_quiet_NaN =3D false; + static constexpr bool has_signaling_NaN =3D false; + static constexpr float_denorm_style has_denorm + =3D denorm_absent; + static constexpr bool has_denorm_loss =3D 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 =3D false; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D true; + + static constexpr bool traps =3D true; + static constexpr bool tinyness_before =3D false; + static constexpr float_round_style round_style + =3D round_toward_zero; + }; +# 1637 "/usr/include/c++/13/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static conste= xpr bool is_specialized =3D 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 (((__int= 128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1)= << 1) + 1) : ~(__int128)0); } static constexpr int digits =3D 128 - 1; sta= tic constexpr int digits10 =3D (128 - 1) * 643L / 2136; static constexpr bo= ol is_signed =3D true; static constexpr bool is_integer =3D true; static co= nstexpr bool is_exact =3D true; static constexpr int radix =3D 2; static co= nstexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128= round_error() noexcept { return 0; } static constexpr __int128 lowest() no= except { return min(); } static constexpr int max_digits10 =3D 0; static co= nstexpr int min_exponent =3D 0; static constexpr int min_exponent10 =3D 0; = static constexpr int max_exponent =3D 0; static constexpr int max_exponent1= 0 =3D 0; static constexpr bool has_infinity =3D false; static constexpr boo= l has_quiet_NaN =3D false; static constexpr bool has_signaling_NaN =3D fals= e; static constexpr float_denorm_style has_denorm =3D denorm_absent; static= constexpr bool has_denorm_loss =3D false; static constexpr __int128 infini= ty() noexcept { return static_cast<__int128>(0); } static constexpr __int12= 8 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexp= r __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } st= atic constexpr __int128 denorm_min() noexcept { return static_cast<__int128= >(0); } static constexpr bool is_iec559 =3D false; static constexpr bool is= _bounded =3D true; static constexpr bool is_modulo =3D false; static conste= xpr bool traps =3D true; static constexpr bool tinyness_before =3D false; s= tatic constexpr float_round_style round_style =3D round_toward_zero; }; __e= xtension__ template<> struct numeric_limits { static con= stexpr bool is_specialized =3D true; static constexpr unsigned __int128 min= () noexcept { return 0; } static constexpr unsigned __int128 max() noexcept= { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((12= 8 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int= 128)0); } static constexpr unsigned __int128 lowest() noexcept { return min= (); } static constexpr int max_digits10 =3D 0; static constexpr int digits = =3D 128; static constexpr int digits10 =3D 128 * 643L / 2136; static conste= xpr bool is_signed =3D false; static constexpr bool is_integer =3D true; st= atic constexpr bool is_exact =3D true; static constexpr int radix =3D 2; st= atic constexpr unsigned __int128 epsilon() noexcept { return 0; } static co= nstexpr unsigned __int128 round_error() noexcept { return 0; } static const= expr int min_exponent =3D 0; static constexpr int min_exponent10 =3D 0; sta= tic constexpr int max_exponent =3D 0; static constexpr int max_exponent10 = =3D 0; static constexpr bool has_infinity =3D false; static constexpr bool = has_quiet_NaN =3D false; static constexpr bool has_signaling_NaN =3D false;= static constexpr float_denorm_style has_denorm =3D denorm_absent; static c= onstexpr bool has_denorm_loss =3D false; static constexpr unsigned __int128= infinity() noexcept { return static_cast(0); } static c= onstexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexc= ept { return static_cast(0); } static constexpr unsigned= __int128 denorm_min() noexcept { return static_cast(0);= } static constexpr bool is_iec559 =3D false; static constexpr bool is_boun= ded =3D true; static constexpr bool is_modulo =3D true; static constexpr bo= ol traps =3D true; static constexpr bool tinyness_before =3D false; static = constexpr float_round_style round_style =3D round_toward_zero; }; +# 1669 "/usr/include/c++/13/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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+3= 8F; } + + + static constexpr int digits =3D 24; + static constexpr int digits10 =3D 6; + + static constexpr int max_digits10 + =3D (2 + (24) * 643L / 2136); + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D false; + static constexpr bool is_exact =3D false; + static constexpr int radix =3D 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7= F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent =3D (-125); + static constexpr int min_exponent10 =3D (-37); + static constexpr int max_exponent =3D 128; + static constexpr int max_exponent10 =3D 38; + + static constexpr bool has_infinity =3D 1; + static constexpr bool has_quiet_NaN =3D 1; + static constexpr bool has_signaling_NaN =3D has_quiet_NaN; + static constexpr float_denorm_style has_denorm + =3D bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + =3D 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.40129846432481707092372958328991613= e-45F; } + + static constexpr bool is_iec559 + =3D has_infinity && has_quiet_NaN && has_denorm =3D=3D denorm_present; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D false; + static constexpr bool tinyness_before + =3D false; + static constexpr float_round_style round_style + =3D round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406= e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357= e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.7976931348623157081452742373170= 4357e+308L); } + + + static constexpr int digits =3D 53; + static constexpr int digits10 =3D 15; + + static constexpr int max_digits10 + =3D (2 + (53) * 643L / 2136); + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D false; + static constexpr bool is_exact =3D false; + static constexpr int radix =3D 2; + + static constexpr double + epsilon() noexcept { return double(2.2204460492503130808472633361816= 4062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent =3D (-1021); + static constexpr int min_exponent10 =3D (-307); + static constexpr int max_exponent =3D 1024; + static constexpr int max_exponent10 =3D 308; + + static constexpr bool has_infinity =3D 1; + static constexpr bool has_quiet_NaN =3D 1; + static constexpr bool has_signaling_NaN =3D has_quiet_NaN; + static constexpr float_denorm_style has_denorm + =3D bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + =3D 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.9406564584124654417656879286= 8221372e-324L); } + + static constexpr bool is_iec559 + =3D has_infinity && has_quiet_NaN && has_denorm =3D=3D denorm_present; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D false; + static constexpr bool tinyness_before + =3D false; + static constexpr float_round_style round_style + =3D round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized =3D 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+4= 932L; } + + + static constexpr int digits =3D 113; + static constexpr int digits10 =3D 33; + + static constexpr int max_digits10 + =3D (2 + (113) * 643L / 2136); + + static constexpr bool is_signed =3D true; + static constexpr bool is_integer =3D false; + static constexpr bool is_exact =3D false; + static constexpr int radix =3D 2; + + static constexpr long double + epsilon() noexcept { return 1.92592994438723585305597794258492732e-3= 4L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent =3D (-16381); + static constexpr int min_exponent10 =3D (-4931); + static constexpr int max_exponent =3D 16384; + static constexpr int max_exponent10 =3D 4932; + + static constexpr bool has_infinity =3D 1; + static constexpr bool has_quiet_NaN =3D 1; + static constexpr bool has_signaling_NaN =3D has_quiet_NaN; + static constexpr float_denorm_style has_denorm + =3D bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + =3D 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.47517511943802511092443895822764655= e-4966L; } + + static constexpr bool is_iec559 + =3D has_infinity && has_quiet_NaN && has_denorm =3D=3D denorm_present; + static constexpr bool is_bounded =3D true; + static constexpr bool is_modulo =3D false; + + static constexpr bool traps =3D false; + static constexpr bool tinyness_before =3D + false; + static constexpr float_round_style round_style =3D + round_to_nearest; + }; +# 2076 "/usr/include/c++/13/limits" 3 + +} +# 45 "/usr/include/c++/13/bits/specfun.h" 2 3 + + +# 1 "/usr/include/c++/13/tr1/gamma.tcc" 1 3 +# 49 "/usr/include/c++/13/tr1/gamma.tcc" 3 +# 1 "/usr/include/c++/13/tr1/special_function_util.h" 1 3 +# 39 "/usr/include/c++/13/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/13/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/include/c++/13/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/include/c++/13/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/include/c++/13/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/13/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] =3D { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n =3D=3D 0) + return _Tp(1); + + if (__n =3D=3D 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 =3D=3D 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact =3D _Tp(1); + if ((__n / 2) % 2 =3D=3D 0) + __fact *=3D _Tp(-1); + for (unsigned int __k =3D 1; __k <=3D __n; ++__k) + __fact *=3D __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *=3D _Tp(2); + + _Tp __sum =3D _Tp(0); + for (unsigned int __i =3D 1; __i < 1000; ++__i) + { + _Tp __term =3D std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum +=3D __term; + } + + return __fact * __sum; + } +# 139 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg =3D (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx =3D __x * __x; + _Tp __help =3D _Tp(1) / __x; + for ( unsigned int __i =3D 1; __i < 20; ++__i ) + { + const _Tp __2i =3D _Tp(2 * __i); + __help /=3D __2i * (__2i - _Tp(1)) * __xx; + __lg +=3D __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 =3D __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] =3D { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + =3D _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum =3D __lanczos_cheb_7[0]; + for(unsigned int __k =3D 1; __k < 9; ++__k) + __sum +=3D __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 =3D (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 =3D __LOGROOT2PI + std::log(__sum); + const _Tp __result =3D __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + =3D std::abs(std::sin(__numeric_constants<_Tp>::__pi() * = __x)); + if (__sin_fact =3D=3D _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " = "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + =3D std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + =3D std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff =3D ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + =3D std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff =3D __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum =3D -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter =3D 100000; + for (unsigned int __k =3D 1; __k < __max_iter; ++__k) + { + const _Tp __term =3D __x / (__k * (__k + __x)); + __sum +=3D __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon= ()) + break; + } + return __sum; + } +# 386 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum =3D std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx =3D __x * __x; + _Tp __xp =3D __xx; + const unsigned int __max_iter =3D 100; + for (unsigned int __k =3D 1; __k < __max_iter; ++__k) + { + const _Tp __term =3D __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp= ); + __sum -=3D __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon= ()) + break; + __xp *=3D __xx; + } + return __sum; + } +# 417 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n =3D static_cast(__x + 0.5L); + const _Tp __eps =3D _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <=3D 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi =3D __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/include/c++/13/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <=3D _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n =3D=3D 0) + return __psi(__x); + else + { + const _Tp __hzeta =3D __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact =3D ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result =3D std::exp(__ln_nfact) * __hzeta; + if (__n % 2 =3D=3D 1) + __result =3D -__result; + return __result; + } + } + } + + + + + + +} +# 48 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl =3D _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi =3D _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 =3D -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 =3D (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 =3D (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x =3D=3D _Tp(0)) + { + if (__nu =3D=3D _Tp(0)) + { + __Jnu =3D _Tp(1); + __Jpnu =3D _Tp(0); + } + else if (__nu =3D=3D _Tp(1)) + { + __Jnu =3D _Tp(0); + __Jpnu =3D _Tp(0.5L); + } + else + { + __Jnu =3D _Tp(0); + __Jpnu =3D _Tp(0); + } + __Nnu =3D -std::numeric_limits<_Tp>::infinity(); + __Npnu =3D std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min =3D std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter =3D 15000; + const _Tp __x_min =3D _Tp(2); + + const int __nl =3D (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L))= )); + + const _Tp __mu =3D __nu - __nl; + const _Tp __mu2 =3D __mu * __mu; + const _Tp __xi =3D _Tp(1) / __x; + const _Tp __xi2 =3D _Tp(2) * __xi; + _Tp __w =3D __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign =3D 1; + _Tp __h =3D __nu * __xi; + if (__h < __fp_min) + __h =3D __fp_min; + _Tp __b =3D __xi2 * __nu; + _Tp __d =3D _Tp(0); + _Tp __c =3D __h; + int __i; + for (__i =3D 1; __i <=3D __max_iter; ++__i) + { + __b +=3D __xi2; + __d =3D __b - __d; + if (std::abs(__d) < __fp_min) + __d =3D __fp_min; + __c =3D __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c =3D __fp_min; + __d =3D _Tp(1) / __d; + const _Tp __del =3D __c * __d; + __h *=3D __del; + if (__d < _Tp(0)) + __isign =3D -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; = " "try asymptotic expansion.") + ); + _Tp __Jnul =3D __isign * __fp_min; + _Tp __Jpnul =3D __h * __Jnul; + _Tp __Jnul1 =3D __Jnul; + _Tp __Jpnu1 =3D __Jpnul; + _Tp __fact =3D __nu * __xi; + for ( int __l =3D __nl; __l >=3D 1; --__l ) + { + const _Tp __Jnutemp =3D __fact * __Jnul + __Jpnul; + __fact -=3D __xi; + __Jpnul =3D __fact * __Jnutemp - __Jnul; + __Jnul =3D __Jnutemp; + } + if (__Jnul =3D=3D _Tp(0)) + __Jnul =3D __eps; + _Tp __f=3D __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 =3D __x / _Tp(2); + const _Tp __pimu =3D __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact =3D (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d =3D -std::log(__x2); + _Tp __e =3D __mu * __d; + _Tp __fact2 =3D (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff =3D (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 = * __d); + __e =3D std::exp(__e); + _Tp __p =3D __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q =3D _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * _= _gammi); + const _Tp __pimu2 =3D __pimu / _Tp(2); + _Tp __fact3 =3D (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r =3D __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3= * __fact3; + _Tp __c =3D _Tp(1); + __d =3D -__x2 * __x2; + _Tp __sum =3D __ff + __r * __q; + _Tp __sum1 =3D __p; + for (__i =3D 1; __i <=3D __max_iter; ++__i) + { + __ff =3D (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *=3D __d / _Tp(__i); + __p /=3D _Tp(__i) - __mu; + __q /=3D _Tp(__i) + __mu; + const _Tp __del =3D __c * (__ff + __r * __q); + __sum +=3D __del; + const _Tp __del1 =3D __c * __p - __i * __del; + __sum1 +=3D __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converg= e " "in __bessel_jn.") + ); + __Nmu =3D -__sum; + __Nnu1 =3D -__sum1 * __xi2; + __Npmu =3D __mu * __xi * __Nmu - __Nnu1; + __Jmu =3D __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a =3D _Tp(0.25L) - __mu2; + _Tp __q =3D _Tp(1); + _Tp __p =3D -__xi / _Tp(2); + _Tp __br =3D _Tp(2) * __x; + _Tp __bi =3D _Tp(2); + _Tp __fact =3D __a * __xi / (__p * __p + __q * __q); + _Tp __cr =3D __br + __q * __fact; + _Tp __ci =3D __bi + __p * __fact; + _Tp __den =3D __br * __br + __bi * __bi; + _Tp __dr =3D __br / __den; + _Tp __di =3D -__bi / __den; + _Tp __dlr =3D __cr * __dr - __ci * __di; + _Tp __dli =3D __cr * __di + __ci * __dr; + _Tp __temp =3D __p * __dlr - __q * __dli; + __q =3D __p * __dli + __q * __dlr; + __p =3D __temp; + int __i; + for (__i =3D 2; __i <=3D __max_iter; ++__i) + { + __a +=3D _Tp(2 * (__i - 1)); + __bi +=3D _Tp(2); + __dr =3D __a * __dr + __br; + __di =3D __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr =3D __fp_min; + __fact =3D __a / (__cr * __cr + __ci * __ci); + __cr =3D __br + __cr * __fact; + __ci =3D __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr =3D __fp_min; + __den =3D __dr * __dr + __di * __di; + __dr /=3D __den; + __di /=3D -__den; + __dlr =3D __cr * __dr - __ci * __di; + __dli =3D __cr * __di + __ci * __dr; + __temp =3D __p * __dlr - __q * __dli; + __q =3D __p * __dli + __q * __dlr; + __p =3D __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bes= sel_jn.") + ); + const _Tp __gam =3D (__p - __f) / __q; + __Jmu =3D std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu =3D ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu =3D __gam * __Jmu; + __Npmu =3D (__p + __q / __gam) * __Nmu; + __Nnu1 =3D __mu * __xi * __Nmu - __Npmu; + } + __fact =3D __Jmu / __Jnul; + __Jnu =3D __fact * __Jnul1; + __Jpnu =3D __fact * __Jpnu1; + for (__i =3D 1; __i <=3D __nl; ++__i) + { + const _Tp __Nnutemp =3D (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu =3D __Nnu1; + __Nnu1 =3D __Nnutemp; + } + __Nnu =3D __Nmu; + __Npnu =3D __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu =3D _Tp(4) * __nu * __nu; + const _Tp __8x =3D _Tp(8) * __x; + + _Tp __P =3D _Tp(0); + _Tp __Q =3D _Tp(0); + + _Tp __k =3D _Tp(0); + _Tp __term =3D _Tp(1); + + int __epsP =3D 0; + int __epsQ =3D 0; + + _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *=3D (__k =3D=3D 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __= 8x)); + + __epsP =3D std::abs(__term) < __eps * std::abs(__P); + __P +=3D __term; + + __k++; + + __term *=3D (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x= ); + __epsQ =3D std::abs(__term) < __eps * std::abs(__Q); + __Q +=3D __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi =3D __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c =3D std::cos(__chi); + const _Tp __s =3D std::sin(__chi); + + const _Tp __coef =3D std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu =3D __coef * (__c * __P - __s * __Q); + __Nnu =3D __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x =3D=3D _Tp(0)) + return __nu =3D=3D _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 =3D __x / _Tp(2); + _Tp __fact =3D __nu * std::log(__x2); + + __fact -=3D ::std::lgamma(__nu + _Tp(1)); + + + + __fact =3D std::exp(__fact); + const _Tp __xx4 =3D __sgn * __x2 * __x2; + _Tp __Jn =3D _Tp(1); + _Tp __term =3D _Tp(1); + + for (unsigned int __i =3D 1; __i < __max_iter; ++__i) + { + __term *=3D __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn +=3D __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon(= )) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu =3D _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor =3D __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n =3D __factor * __J_nu; + __n_n =3D __factor * __N_nu; + __jp_n =3D __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n =3D __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x =3D=3D _Tp(0)) + { + if (__n =3D=3D 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/include/c++/13/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x =3D=3D _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 49 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/beta_function.tcc" 1 3 +# 49 "/usr/include/c++/13/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet =3D ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *=3D ::std::tgamma(__y); + } + else + { + __bet =3D ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *=3D ::std::tgamma(__x); + } +# 111 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet =3D ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet =3D std::exp(__bet); + return __bet; + } +# 158 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet =3D (__x + __y) / (__x * __y); + + unsigned int __max_iter =3D 1000000; + for (unsigned int __k =3D 1; __k < __max_iter; ++__k) + { + _Tp __term =3D (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *=3D __term; + } + + return __bet; + } +# 189 "/usr/include/c++/13/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 50 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min =3D std::numeric_limits<_Tp>::min(); + const _Tp __lolim =3D _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint= _rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 =3D _Tp(1) / _Tp(4); + const _Tp __c1 =3D _Tp(1) / _Tp(24); + const _Tp __c2 =3D _Tp(1) / _Tp(10); + const _Tp __c3 =3D _Tp(3) / _Tp(44); + const _Tp __c4 =3D _Tp(1) / _Tp(14); + + _Tp __xn =3D __x; + _Tp __yn =3D __y; + _Tp __zn =3D __z; + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol =3D std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter =3D 100; + for (unsigned int __iter =3D 0; __iter < __max_iter; ++__iter) + { + __mu =3D (__xn + __yn + __zn) / _Tp(3); + __xndev =3D 2 - (__mu + __xn) / __mu; + __yndev =3D 2 - (__mu + __yn) / __mu; + __zndev =3D 2 - (__mu + __zn) / __mu; + _Tp __epsilon =3D std::max(std::abs(__xndev), std::abs(__ynd= ev)); + __epsilon =3D std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot =3D std::sqrt(__xn); + const _Tp __ynroot =3D std::sqrt(__yn); + const _Tp __znroot =3D std::sqrt(__zn); + const _Tp __lambda =3D __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn =3D __c0 * (__xn + __lambda); + __yn =3D __c0 * (__yn + __lambda); + __zn =3D __c0 * (__zn + __lambda); + } + + const _Tp __e2 =3D __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 =3D __xndev * __yndev * __zndev; + const _Tp __s =3D _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * = __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk =3D __k * __k; + + _Tp __term =3D __kk / _Tp(4); + _Tp __sum =3D _Tp(1) + __term; + + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 2; __i < __max_iter; ++__i) + { + __term *=3D (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum +=3D __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >=3D _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n =3D std::floor(__phi / __numeric_constants<_Tp>::_= _pi() + + _Tp(0.5L)); + const _Tp __phi_red =3D __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s =3D std::sin(__phi_red); + const _Tp __c =3D std::cos(__phi_red); + + const _Tp __F =3D __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n =3D=3D 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk =3D __k * __k; + + _Tp __term =3D __kk; + _Tp __sum =3D __term; + + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 2; __i < __max_iter; ++__i) + { + const _Tp __i2m =3D 2 * __i - 1; + const _Tp __i2 =3D 2 * __i; + __term *=3D __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum +=3D __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol =3D std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max =3D std::numeric_limits<_Tp>::max(); + const _Tp __lolim =3D _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint= _rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 =3D _Tp(1) / _Tp(4); + const _Tp __c1 =3D _Tp(3) / _Tp(14); + const _Tp __c2 =3D _Tp(1) / _Tp(6); + const _Tp __c3 =3D _Tp(9) / _Tp(22); + const _Tp __c4 =3D _Tp(3) / _Tp(26); + + _Tp __xn =3D __x; + _Tp __yn =3D __y; + _Tp __zn =3D __z; + _Tp __sigma =3D _Tp(0); + _Tp __power4 =3D _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter =3D 100; + for (unsigned int __iter =3D 0; __iter < __max_iter; ++__iter) + { + __mu =3D (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev =3D (__mu - __xn) / __mu; + __yndev =3D (__mu - __yn) / __mu; + __zndev =3D (__mu - __zn) / __mu; + _Tp __epsilon =3D std::max(std::abs(__xndev), std::abs(__ynd= ev)); + __epsilon =3D std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot =3D std::sqrt(__xn); + _Tp __ynroot =3D std::sqrt(__yn); + _Tp __znroot =3D std::sqrt(__zn); + _Tp __lambda =3D __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma +=3D __power4 / (__znroot * (__zn + __lambda)); + __power4 *=3D __c0; + __xn =3D __c0 * (__xn + __lambda); + __yn =3D __c0 * (__yn + __lambda); + __zn =3D __c0 * (__zn + __lambda); + } + + _Tp __ea =3D __xndev * __yndev; + _Tp __eb =3D __zndev * __zndev; + _Tp __ec =3D __ea - __eb; + _Tp __ed =3D __ea - _Tp(6) * __eb; + _Tp __ef =3D __ed + __ec + __ec; + _Tp __s1 =3D __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __= ef + / _Tp(2)); + _Tp __s2 =3D __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) =3D=3D 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk =3D __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3= ); + } + } +# 433 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n =3D std::floor(__phi / __numeric_constants<_Tp>::_= _pi() + + _Tp(0.5L)); + const _Tp __phi_red =3D __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk =3D __k * __k; + const _Tp __s =3D std::sin(__phi_red); + const _Tp __ss =3D __s * __s; + const _Tp __sss =3D __ss * __s; + const _Tp __c =3D std::cos(__phi_red); + const _Tp __cc =3D __c * __c; + + const _Tp __E =3D __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n =3D=3D 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min =3D std::numeric_limits<_Tp>::min(); + const _Tp __lolim =3D _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint= _rc.") + ); + else + { + const _Tp __c0 =3D _Tp(1) / _Tp(4); + const _Tp __c1 =3D _Tp(1) / _Tp(7); + const _Tp __c2 =3D _Tp(9) / _Tp(22); + const _Tp __c3 =3D _Tp(3) / _Tp(10); + const _Tp __c4 =3D _Tp(3) / _Tp(8); + + _Tp __xn =3D __x; + _Tp __yn =3D __y; + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol =3D std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)= ); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter =3D 100; + for (unsigned int __iter =3D 0; __iter < __max_iter; ++__iter) + { + __mu =3D (__xn + _Tp(2) * __yn) / _Tp(3); + __sn =3D (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda =3D _Tp(2) * std::sqrt(__xn) * std::sqrt(= __yn) + + __yn; + __xn =3D __c0 * (__xn + __lambda); + __yn =3D __c0 * (__yn + __lambda); + } + + _Tp __s =3D __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min =3D std::numeric_limits<_Tp>::min(); + const _Tp __lolim =3D std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint= _rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 =3D _Tp(1) / _Tp(4); + const _Tp __c1 =3D _Tp(3) / _Tp(14); + const _Tp __c2 =3D _Tp(1) / _Tp(3); + const _Tp __c3 =3D _Tp(3) / _Tp(22); + const _Tp __c4 =3D _Tp(3) / _Tp(26); + + _Tp __xn =3D __x; + _Tp __yn =3D __y; + _Tp __zn =3D __z; + _Tp __pn =3D __p; + _Tp __sigma =3D _Tp(0); + _Tp __power4 =3D _Tp(1); + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol =3D std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter =3D 100; + for (unsigned int __iter =3D 0; __iter < __max_iter; ++__iter) + { + __mu =3D (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev =3D (__mu - __xn) / __mu; + __yndev =3D (__mu - __yn) / __mu; + __zndev =3D (__mu - __zn) / __mu; + __pndev =3D (__mu - __pn) / __mu; + _Tp __epsilon =3D std::max(std::abs(__xndev), std::abs(__ynd= ev)); + __epsilon =3D std::max(__epsilon, std::abs(__zndev)); + __epsilon =3D std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot =3D std::sqrt(__xn); + const _Tp __ynroot =3D std::sqrt(__yn); + const _Tp __znroot =3D std::sqrt(__zn); + const _Tp __lambda =3D __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 =3D __pn * (__xnroot + __ynroot + __znroo= t) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 =3D __alpha1 * __alpha1; + const _Tp __beta =3D __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma +=3D __power4 * __ellint_rc(__alpha2, __beta); + __power4 *=3D __c0; + __xn =3D __c0 * (__xn + __lambda); + __yn =3D __c0 * (__yn + __lambda); + __zn =3D __c0 * (__zn + __lambda); + __pn =3D __c0 * (__pn + __lambda); + } + + _Tp __ea =3D __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb =3D __xndev * __yndev * __zndev; + _Tp __ec =3D __pndev * __pndev; + _Tp __e2 =3D __ea - _Tp(3) * __ec; + _Tp __e3 =3D __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 =3D _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp= (4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 =3D __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 =3D __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu =3D=3D _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk =3D __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/include/c++/13/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n =3D std::floor(__phi / __numeric_constants<_Tp>::_= _pi() + + _Tp(0.5L)); + const _Tp __phi_red =3D __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk =3D __k * __k; + const _Tp __s =3D std::sin(__phi_red); + const _Tp __ss =3D __s * __s; + const _Tp __sss =3D __ss * __s; + const _Tp __c =3D std::cos(__phi_red); + const _Tp __cc =3D __c * __c; + + const _Tp __Pi =3D __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n =3D=3D 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 51 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + _Tp __term =3D _Tp(1); + _Tp __esum =3D _Tp(0); + _Tp __osum =3D _Tp(0); + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 1; __i < __max_iter; ++__i) + { + __term *=3D - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >=3D _Tp(0)) + __esum +=3D __term / __i; + else + __osum +=3D __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term =3D _Tp(1); + _Tp __esum =3D _Tp(1); + _Tp __osum =3D _Tp(0); + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 1; __i < __max_iter; ++__i) + { + _Tp __prev =3D __term; + __term *=3D - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >=3D _Tp(0)) + __esum +=3D __term; + else + __osum +=3D __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter =3D 1000; + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const int __nm1 =3D __n - 1; + _Tp __ans =3D (__nm1 !=3D 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()= ); + _Tp __fact =3D _Tp(1); + for (int __i =3D 1; __i <=3D __max_iter; ++__i) + { + __fact *=3D -__x / _Tp(__i); + _Tp __del; + if ( __i !=3D __nm1 ) + __del =3D -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi =3D -__numeric_constants<_Tp>::gamma_e(); + for (int __ii =3D 1; __ii <=3D __nm1; ++__ii) + __psi +=3D _Tp(1) / _Tp(__ii); + __del =3D __fact * (__psi - std::log(__x)); + } + __ans +=3D __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_= En_series.") + ); + } +# 201 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter =3D 1000; + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min =3D std::numeric_limits<_Tp>::min(); + const int __nm1 =3D __n - 1; + _Tp __b =3D __x + _Tp(__n); + _Tp __c =3D _Tp(1) / __fp_min; + _Tp __d =3D _Tp(1) / __b; + _Tp __h =3D __d; + for ( unsigned int __i =3D 1; __i <=3D __max_iter; ++__i ) + { + _Tp __a =3D -_Tp(__i * (__nm1 + __i)); + __b +=3D _Tp(2); + __d =3D _Tp(1) / (__a * __d + __b); + __c =3D __b + __a / __c; + const _Tp __del =3D __c * __d; + __h *=3D __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans =3D __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expin= t_En_cont_frac.") + ); + } +# 246 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 =3D __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En =3D __E1; + for (unsigned int __j =3D 2; __j < __n; ++__j) + __En =3D (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En =3D _Tp(1); + const int __N =3D __n + 20; + _Tp __save =3D _Tp(0); + for (int __j =3D __N; __j > 0; --__j) + { + __En =3D (std::exp(-__x) - __j * __En) / __x; + if (__j =3D=3D __n) + __save =3D __En; + } + _Tp __norm =3D __En / __E1; + __En /=3D __norm; + } + + return __En; + } +# 290 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term =3D _Tp(1); + _Tp __sum =3D _Tp(0); + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 1; __i < __max_iter; ++__i) + { + __term *=3D __x / __i; + __sum +=3D __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term =3D _Tp(1); + _Tp __sum =3D _Tp(1); + const unsigned int __max_iter =3D 1000; + for (unsigned int __i =3D 1; __i < __max_iter; ++__i) + { + _Tp __prev =3D __term; + __term *=3D __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >=3D __prev) + break; + __sum +=3D __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term =3D _Tp(1); + _Tp __sum =3D _Tp(1); + for (unsigned int __i =3D 1; __i <=3D __n; ++__i) + { + _Tp __prev =3D __term; + __term *=3D -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum +=3D __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn =3D __x + __n; + const _Tp __xpn2 =3D __xpn * __xpn; + _Tp __term =3D _Tp(1); + _Tp __sum =3D _Tp(1); + for (unsigned int __i =3D 1; __i <=3D __n; ++__i) + { + _Tp __prev =3D __term; + __term *=3D (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum +=3D __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <=3D 1 && __x =3D=3D _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 =3D std::exp(__x) / __x; + if (__n =3D=3D 0) + return __E0; + + _Tp __E1 =3D __expint_E1(__x); + if (__n =3D=3D 1) + return __E1; + + if (__x =3D=3D _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En =3D __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/include/c++/13/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 52 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + _Tp __term =3D _Tp(1); + _Tp __Fac =3D _Tp(1); + const unsigned int __max_iter =3D 100000; + unsigned int __i; + for (__i =3D 0; __i < __max_iter; ++__i) + { + __term *=3D (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac +=3D __term; + } + if (__i =3D=3D __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __con= f_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big =3D std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.= 16L)); + const int __nmax =3D 20000; + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __x =3D -__xin; + const _Tp __x3 =3D __x * __x * __x; + const _Tp __t0 =3D __a / __c; + const _Tp __t1 =3D (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 =3D (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F =3D _Tp(1); + _Tp __prec; + + _Tp __Bnm3 =3D _Tp(1); + _Tp __Bnm2 =3D _Tp(1) + __t1 * __x; + _Tp __Bnm1 =3D _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 =3D _Tp(1); + _Tp __Anm2 =3D __Bnm2 - __t0 * __x; + _Tp __Anm1 =3D __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n =3D 3; + while(1) + { + _Tp __npam1 =3D _Tp(__n - 1) + __a; + _Tp __npcm1 =3D _Tp(__n - 1) + __c; + _Tp __npam2 =3D _Tp(__n - 2) + __a; + _Tp __npcm2 =3D _Tp(__n - 2) + __c; + _Tp __tnm1 =3D _Tp(2 * __n - 1); + _Tp __tnm3 =3D _Tp(2 * __n - 3); + _Tp __tnm5 =3D _Tp(2 * __n - 5); + _Tp __F1 =3D (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 =3D (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 =3D -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E =3D -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An =3D (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __A= nm3; + _Tp __Bn =3D (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __B= nm3; + _Tp __r =3D __An / __Bn; + + __prec =3D std::abs((__F - __r) / __F); + __F =3D __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /=3D __big; + __Bn /=3D __big; + __Anm1 /=3D __big; + __Bnm1 /=3D __big; + __Anm2 /=3D __big; + __Bnm2 /=3D __big; + __Anm3 /=3D __big; + __Bnm3 /=3D __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *=3D __big; + __Bn *=3D __big; + __Anm1 *=3D __big; + __Bnm1 *=3D __big; + __Anm2 *=3D __big; + __Bnm2 *=3D __big; + __Anm3 *=3D __big; + __Bnm3 *=3D __big; + } + + ++__n; + __Bnm3 =3D __Bnm2; + __Bnm2 =3D __Bnm1; + __Bnm1 =3D __Bn; + __Anm3 =3D __Anm2; + __Anm2 =3D __Anm1; + __Anm1 =3D __An; + } + + if (__n >=3D __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __= conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint =3D ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint =3D=3D __c && __c_nint <=3D 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a =3D=3D _Tp(0)) + return _Tp(1); + else if (__c =3D=3D __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + _Tp __term =3D _Tp(1); + _Tp __Fabc =3D _Tp(1); + const unsigned int __max_iter =3D 100000; + unsigned int __i; + for (__i =3D 0; __i < __max_iter; ++__i) + { + __term *=3D (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc +=3D __term; + } + if (__i =3D=3D __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyp= erg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big =3D std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.= 16L)); + const int __nmax =3D 20000; + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __x =3D -__xin; + const _Tp __x3 =3D __x * __x * __x; + const _Tp __t0 =3D __a * __b / __c; + const _Tp __t1 =3D (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 =3D (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F =3D _Tp(1); + + _Tp __Bnm3 =3D _Tp(1); + _Tp __Bnm2 =3D _Tp(1) + __t1 * __x; + _Tp __Bnm1 =3D _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 =3D _Tp(1); + _Tp __Anm2 =3D __Bnm2 - __t0 * __x; + _Tp __Anm1 =3D __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n =3D 3; + while (1) + { + const _Tp __npam1 =3D _Tp(__n - 1) + __a; + const _Tp __npbm1 =3D _Tp(__n - 1) + __b; + const _Tp __npcm1 =3D _Tp(__n - 1) + __c; + const _Tp __npam2 =3D _Tp(__n - 2) + __a; + const _Tp __npbm2 =3D _Tp(__n - 2) + __b; + const _Tp __npcm2 =3D _Tp(__n - 2) + __c; + const _Tp __tnm1 =3D _Tp(2 * __n - 1); + const _Tp __tnm3 =3D _Tp(2 * __n - 3); + const _Tp __tnm5 =3D _Tp(2 * __n - 5); + const _Tp __n2 =3D __n * __n; + const _Tp __F1 =3D (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 =3D -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 =3D (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E =3D -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An =3D (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __A= nm3; + _Tp __Bn =3D (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __B= nm3; + const _Tp __r =3D __An / __Bn; + + const _Tp __prec =3D std::abs((__F - __r) / __F); + __F =3D __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /=3D __big; + __Bn /=3D __big; + __Anm1 /=3D __big; + __Bnm1 /=3D __big; + __Anm2 /=3D __big; + __Bnm2 /=3D __big; + __Anm3 /=3D __big; + __Bnm3 /=3D __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *=3D __big; + __Bn *=3D __big; + __Anm1 *=3D __big; + __Bnm1 *=3D __big; + __Anm2 *=3D __big; + __Bnm2 *=3D __big; + __Anm3 *=3D __big; + __Bnm3 *=3D __big; + } + + ++__n; + __Bnm3 =3D __Bnm2; + __Bnm2 =3D __Bnm1; + __Bnm1 =3D __Bn; + __Anm3 =3D __Anm2; + __Anm2 =3D __Anm1; + __Anm1 =3D __An; + } + + if (__n >=3D __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __= hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d =3D __c - __a - __b; + const int __intd =3D std::floor(__d + _Tp(0.5L)); + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler =3D _Tp(1000) * __eps; + const _Tp __log_max =3D std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer =3D (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx =3D std::log(_Tp(1) - __x); + const _Tp __ad =3D std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >=3D _Tp(0)) + { + __d1 =3D __d; + __d2 =3D _Tp(0); + } + else + { + __d1 =3D _Tp(0); + __d2 =3D __d; + } + + const _Tp __lng_c =3D __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 =3D _Tp(0); + } + else + { + + bool __ok_d1 =3D true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + if (true) + { + __lng_ad =3D __log_gamma(__ad); + __lng_ad1 =3D __log_gamma(__a + __d1); + __lng_bd1 =3D __log_gamma(__b + __d1); + } + if (false) + { + __ok_d1 =3D false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 =3D _Tp(1); + _Tp __term =3D _Tp(1); + _Tp __ln_pre1 =3D __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i =3D 1; __i < __ad; ++__i) + { + const int __j =3D __i - 1; + __term *=3D (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __= x); + __sum1 +=3D __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functio= ns" " in __hyperg_luke.") + ); + else + __F1 =3D std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 =3D _Tp(0); + } + } + + + bool __ok_d2 =3D true; + _Tp __lng_ad2, __lng_bd2; + if (true) + { + __lng_ad2 =3D __log_gamma(__a + __d2); + __lng_bd2 =3D __log_gamma(__b + __d2); + } + if (false) + { + __ok_d2 =3D false; + } + + if (__ok_d2) + { + + + const int __maxiter =3D 2000; + const _Tp __psi_1 =3D -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd =3D __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 =3D __psi(__a + __d1); + const _Tp __psi_bpd1 =3D __psi(__b + __d1); + + _Tp __psi_term =3D __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact =3D _Tp(1); + _Tp __sum2 =3D __psi_term; + _Tp __ln_pre2 =3D __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j =3D 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 =3D _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 =3D _Tp(1) / (__a + __d1 + _Tp(__j - 1= )) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term +=3D __term1 - __term2; + __fact *=3D (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta =3D __fact * __psi_term; + __sum2 +=3D __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j =3D=3D __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "= in __hyperg_reflect") + ); + + if (__sum2 =3D=3D _Tp(0)) + __F2 =3D _Tp(0); + else + __F2 =3D std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 =3D _Tp(0); + } + + const _Tp __sgn_2 =3D (__intd % 2 =3D=3D 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F =3D __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 =3D true; + _Tp __sgn_g1ca =3D _Tp(0), __ln_g1ca =3D _Tp(0); + _Tp __sgn_g1cb =3D _Tp(0), __ln_g1cb =3D _Tp(0); + if (true) + { + __sgn_g1ca =3D __log_gamma_sign(__c - __a); + __ln_g1ca =3D __log_gamma(__c - __a); + __sgn_g1cb =3D __log_gamma_sign(__c - __b); + __ln_g1cb =3D __log_gamma(__c - __b); + } + if (false) + { + __ok1 =3D false; + } + + bool __ok2 =3D true; + _Tp __sgn_g2a =3D _Tp(0), __ln_g2a =3D _Tp(0); + _Tp __sgn_g2b =3D _Tp(0), __ln_g2b =3D _Tp(0); + if (true) + { + __sgn_g2a =3D __log_gamma_sign(__a); + __ln_g2a =3D __log_gamma(__a); + __sgn_g2b =3D __log_gamma_sign(__b); + __ln_g2b =3D __log_gamma(__b); + } + if (false) + { + __ok2 =3D false; + } + + const _Tp __sgn_gc =3D __log_gamma_sign(__c); + const _Tp __ln_gc =3D __log_gamma(__c); + const _Tp __sgn_gd =3D __log_gamma_sign(__d); + const _Tp __ln_gd =3D __log_gamma(__d); + const _Tp __sgn_gmd =3D __log_gamma_sign(-__d); + const _Tp __ln_gmd =3D __log_gamma(-__d); + + const _Tp __sgn1 =3D __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1= cb; + const _Tp __sgn2 =3D __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2= b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 =3D __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 =3D __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 =3D std::exp(__ln_pre1); + __pre2 =3D std::exp(__ln_pre2); + __pre1 *=3D __sgn1; + __pre2 *=3D __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions= " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 =3D __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 =3D std::exp(__ln_pre1); + __pre1 *=3D __sgn1; + __pre2 =3D _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions= " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 =3D __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 =3D _Tp(0); + __pre2 =3D std::exp(__ln_pre2); + __pre2 *=3D __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions= " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 =3D _Tp(0); + __pre2 =3D _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " = "in __hyperg_reflect") + ); + } + + const _Tp __F1 =3D __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 =3D __hyperg_series(__c - __a, __c - __b, _Tp(1) = + __d, + _Tp(1) - __x); + + const _Tp __F =3D __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/include/c++/13/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint =3D ::std::nearbyint(__a); + const _Tp __b_nint =3D ::std::nearbyint(__b); + const _Tp __c_nint =3D ::std::nearbyint(__c); + + + + + + const _Tp __toler =3D _Tp(1000) * std::numeric_limits<_Tp>::epsilon(= ); + if (std::abs(__x) >=3D _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __h= yperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint =3D=3D __c && __c_nint <=3D _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __to= ler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >=3D _Tp(0) && __b >=3D _Tp(0) && __c >=3D _Tp(0) + && __x >=3D _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 53 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/include/c++/13/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/13/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/include/c++/13/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x =3D=3D +_Tp(1)) + return +_Tp(1); + else if (__x =3D=3D -_Tp(1)) + return (__l % 2 =3D=3D 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 =3D _Tp(1); + if (__l =3D=3D 0) + return __p_lm2; + + _Tp __p_lm1 =3D __x; + if (__l =3D=3D 1) + return __p_lm1; + + _Tp __p_l =3D 0; + for (unsigned int __ll =3D 2; __ll <=3D __l; ++__ll) + { + + + __p_l =3D _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 =3D __p_lm1; + __p_lm1 =3D __p_l; + } + + return __p_l; + } + } +# 136 "/usr/include/c++/13/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase =3D _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m =3D=3D 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm =3D _Tp(1); + if (__m > 0) + { + + + _Tp __root =3D std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + = __x); + _Tp __fact =3D _Tp(1); + for (unsigned int __i =3D 1; __i <=3D __m; ++__i) + { + __p_mm *=3D __phase * __fact * __root; + __fact +=3D _Tp(2); + } + } + if (__l =3D=3D __m) + return __p_mm; + + _Tp __p_mp1m =3D _Tp(2 * __m + 1) * __x * __p_mm; + if (__l =3D=3D __m + 1) + return __p_mp1m; + + _Tp __p_lm2m =3D __p_mm; + _Tp __P_lm1m =3D __p_mp1m; + _Tp __p_lm =3D _Tp(0); + for (unsigned int __j =3D __m + 2; __j <=3D __l; ++__j) + { + __p_lm =3D (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m =3D __P_lm1m; + __P_lm1m =3D __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/include/c++/13/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x =3D std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m =3D=3D 0) + { + _Tp __P =3D __poly_legendre_p(__l, __x); + _Tp __fact =3D std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *=3D __fact; + return __P; + } + else if (__x =3D=3D _Tp(1) || __x =3D=3D -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn =3D ( __m % 2 =3D=3D 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor =3D __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc =3D ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch =3D ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val =3D + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr =3D std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm =3D __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m =3D __y_mp1m_factor * __y_mm; + + if (__l =3D=3D __m) + return __y_mm; + else if (__l =3D=3D __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm =3D _Tp(0); + + + for (unsigned int __ll =3D __m + 2; __ll <=3D __l; ++__ll) + { + const _Tp __rat1 =3D _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 =3D _Tp(__ll - __m - 1) / _Tp(__ll + __= m - 1); + const _Tp __fact1 =3D std::sqrt(__rat1 * _Tp(2 * __ll + = 1) + * _Tp(2 * __ll - 1)= ); + const _Tp __fact2 =3D std::sqrt(__rat1 * __rat2 * _Tp(2 = * __ll + 1) + / _Tp(2 * = __ll - 3)); + __y_lm =3D (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll= - __m); + __y_mm =3D __y_mp1m; + __y_mp1m =3D __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 54 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x =3D=3D _Tp(0)) + { + if (__nu =3D=3D _Tp(0)) + { + __Inu =3D _Tp(1); + __Ipnu =3D _Tp(0); + } + else if (__nu =3D=3D _Tp(1)) + { + __Inu =3D _Tp(0); + __Ipnu =3D _Tp(0.5L); + } + else + { + __Inu =3D _Tp(0); + __Ipnu =3D _Tp(0); + } + __Knu =3D std::numeric_limits<_Tp>::infinity(); + __Kpnu =3D -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min =3D _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter =3D 15000; + const _Tp __x_min =3D _Tp(2); + + const int __nl =3D static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu =3D __nu - __nl; + const _Tp __mu2 =3D __mu * __mu; + const _Tp __xi =3D _Tp(1) / __x; + const _Tp __xi2 =3D _Tp(2) * __xi; + _Tp __h =3D __nu * __xi; + if ( __h < __fp_min ) + __h =3D __fp_min; + _Tp __b =3D __xi2 * __nu; + _Tp __d =3D _Tp(0); + _Tp __c =3D __h; + int __i; + for ( __i =3D 1; __i <=3D __max_iter; ++__i ) + { + __b +=3D __xi2; + __d =3D _Tp(1) / (__b + __d); + __c =3D __b + _Tp(1) / __c; + const _Tp __del =3D __c * __d; + __h *=3D __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_i= k; " "try asymptotic expansion.") + + ); + _Tp __Inul =3D __fp_min; + _Tp __Ipnul =3D __h * __Inul; + _Tp __Inul1 =3D __Inul; + _Tp __Ipnu1 =3D __Ipnul; + _Tp __fact =3D __nu * __xi; + for (int __l =3D __nl; __l >=3D 1; --__l) + { + const _Tp __Inutemp =3D __fact * __Inul + __Ipnul; + __fact -=3D __xi; + __Ipnul =3D __fact * __Inutemp + __Inul; + __Inul =3D __Inutemp; + } + _Tp __f =3D __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 =3D __x / _Tp(2); + const _Tp __pimu =3D __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact =3D (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d =3D -std::log(__x2); + _Tp __e =3D __mu * __d; + const _Tp __fact2 =3D (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff =3D __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum =3D __ff; + __e =3D std::exp(__e); + _Tp __p =3D __e / (_Tp(2) * __gampl); + _Tp __q =3D _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c =3D _Tp(1); + __d =3D __x2 * __x2; + _Tp __sum1 =3D __p; + int __i; + for (__i =3D 1; __i <=3D __max_iter; ++__i) + { + __ff =3D (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *=3D __d / __i; + __p /=3D __i - __mu; + __q /=3D __i + __mu; + const _Tp __del =3D __c * __ff; + __sum +=3D __del; + const _Tp __del1 =3D __c * (__p - __i * __ff); + __sum1 +=3D __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converg= e " "in __bessel_ik.") + ); + __Kmu =3D __sum; + __Knu1 =3D __sum1 * __xi2; + } + else + { + _Tp __b =3D _Tp(2) * (_Tp(1) + __x); + _Tp __d =3D _Tp(1) / __b; + _Tp __delh =3D __d; + _Tp __h =3D __delh; + _Tp __q1 =3D _Tp(0); + _Tp __q2 =3D _Tp(1); + _Tp __a1 =3D _Tp(0.25L) - __mu2; + _Tp __q =3D __c =3D __a1; + _Tp __a =3D -__a1; + _Tp __s =3D _Tp(1) + __q * __delh; + int __i; + for (__i =3D 2; __i <=3D __max_iter; ++__i) + { + __a -=3D 2 * (__i - 1); + __c =3D -__a * __c / __i; + const _Tp __qnew =3D (__q1 - __b * __q2) / __a; + __q1 =3D __q2; + __q2 =3D __qnew; + __q +=3D __c * __qnew; + __b +=3D _Tp(2); + __d =3D _Tp(1) / (__b + __a * __d); + __delh =3D (__b * __d - _Tp(1)) * __delh; + __h +=3D __delh; + const _Tp __dels =3D __q * __delh; + __s +=3D __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bes= sel_ik.") + ); + __h =3D __a1 * __h; + __Kmu =3D std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) *= __x)) + * std::exp(-__x) / __s; + __Knu1 =3D __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu =3D __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu =3D __xi / (__f * __Kmu - __Kpmu); + __Inu =3D __Inumu * __Inul1 / __Inul; + __Ipnu =3D __Inumu * __Ipnu1 / __Inul; + for ( __i =3D 1; __i <=3D __nl; ++__i ) + { + const _Tp __Knutemp =3D (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu =3D __Knu1; + __Knu1 =3D __Knutemp; + } + __Knu =3D __Kmu; + __Kpnu =3D __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu =3D _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor =3D __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n =3D __factor * __I_nu; + __k_n =3D __factor * __K_nu; + __ip_n =3D __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n =3D __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/include/c++/13/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx =3D std::abs(__x); + const _Tp __rootx =3D std::sqrt(__absx); + const _Tp __z =3D _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf =3D std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip =3D __Aip =3D __Bi =3D __Ai =3D std::numeric_limits<_Tp>::qu= iet_NaN(); + else if (__z =3D=3D _S_inf) + { + __Aip =3D __Ai =3D _Tp(0); + __Bip =3D __Bi =3D _S_inf; + } + else if (__z =3D=3D -_S_inf) + __Bip =3D __Aip =3D __Bi =3D __Ai =3D _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_= nu); + __Ai =3D __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi =3D __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_= nu); + __Aip =3D -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip =3D __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_= nu); + __Ai =3D __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(= 2); + __Bi =3D -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(= 2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_= nu); + __Aip =3D __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip =3D __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai =3D _Tp(0.35502805388781723926L); + __Bi =3D __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip =3D -_Tp(0.25881940379280679840L); + __Bip =3D -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 55 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/include/c++/13/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/13/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/include/c++/13/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 =3D 1; + if (__n =3D=3D 0) + return __H_0; + + + _Tp __H_1 =3D 2 * __x; + if (__n =3D=3D 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 =3D __H_0, __H_nm1 =3D __H_1, __i =3D 2; __i <=3D __n; = ++__i) + { + __H_n =3D 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 =3D __H_nm1; + __H_nm1 =3D __H_n; + } + + return __H_n; + } +# 114 "/usr/include/c++/13/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 56 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a =3D -_Tp(__n); + const _Tp __b =3D _Tp(__alpha1) + _Tp(1); + const _Tp __eta =3D _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th =3D __x / __eta; + const _Tp __sin2th =3D _Tp(1) - __cos2th; + const _Tp __th =3D std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h =3D __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b =3D ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact =3D ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 =3D _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 =3D _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre =3D __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 =3D std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 =3D std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser =3D __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b =3D _Tp(__alpha1) + _Tp(1); + const _Tp __mx =3D -__x; + const _Tp __tc_sgn =3D (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 =3D=3D 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc =3D _Tp(1); + const _Tp __ax =3D std::abs(__x); + for (unsigned int __k =3D 1; __k <=3D __n; ++__k) + __tc *=3D (__ax / __k); + + _Tp __term =3D __tc * __tc_sgn; + _Tp __sum =3D __term; + for (int __k =3D int(__n) - 1; __k >=3D 0; --__k) + { + __term *=3D ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum +=3D __term; + } + + return __sum; + } +# 185 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 =3D _Tp(1); + if (__n =3D=3D 0) + return __l_0; + + + _Tp __l_1 =3D -__x + _Tp(1) + _Tp(__alpha1); + if (__n =3D=3D 1) + return __l_1; + + + _Tp __l_n2 =3D __l_0; + _Tp __l_n1 =3D __l_1; + _Tp __l_n =3D _Tp(0); + for (unsigned int __nn =3D 2; __nn <=3D __n; ++__nn) + { + __l_n =3D (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 =3D __l_n1; + __l_n1 =3D __l_n; + } + + return __l_n; + } +# 244 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerr= e.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n =3D=3D 0) + return _Tp(1); + else if (__n =3D=3D 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x =3D=3D _Tp(0)) + { + _Tp __prod =3D _Tp(__alpha1) + _Tp(1); + for (unsigned int __k =3D 2; __k <=3D __n; ++__k) + __prod *=3D (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >=3D _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/include/c++/13/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 57 "/usr/include/c++/13/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter =3D 10000; + _Tp __zeta =3D _Tp(0); + for (unsigned int __k =3D 1; __k < max_iter; ++__k) + { + _Tp __term =3D std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta +=3D __term; + } + + return __zeta; + } +# 115 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn =3D _Tp(1); + _Tp __zeta =3D _Tp(0); + for (unsigned int __i =3D 1; __i < 10000000; ++__i) + { + _Tp __term =3D __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta +=3D __term; + __sgn *=3D _Tp(-1); + } + __zeta /=3D _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta =3D _Tp(0); + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff =3D std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) =3D=3D _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta =3D __riemann_zeta_glob(_Tp(1) - __s); + __zeta *=3D std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num =3D _Tp(0.5L); + const unsigned int __maxit =3D 10000; + for (unsigned int __i =3D 0; __i < __maxit; ++__i) + { + bool __punt =3D false; + _Tp __sgn =3D _Tp(1); + _Tp __term =3D _Tp(0); + for (unsigned int __j =3D 0; __j <=3D __i; ++__j) + { + + _Tp __bincoeff =3D ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt =3D true; + break; + } + __bincoeff =3D std::exp(__bincoeff); + __term +=3D __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s= ); + __sgn *=3D _Tp(-1); + } + if (__punt) + break; + __term *=3D __num; + __zeta +=3D __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *=3D _Tp(0.5L); + } + + __zeta /=3D _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] =3D { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes =3D sizeof(__prime) / sizeof(= _Tp); + + _Tp __zeta =3D _Tp(1); + for (unsigned int __i =3D 0; __i < __num_primes; ++__i) + { + const _Tp __fact =3D _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *=3D __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta =3D _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s =3D=3D _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta =3D __riemann_zeta_product(_Tp(1) - __s); + __zeta *=3D std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), = __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob =3D true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta =3D std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * _= _s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta =3D _Tp(0); + + const _Tp __eps =3D std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff =3D std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit =3D 10000; + for (unsigned int __i =3D 0; __i < __maxit; ++__i) + { + bool __punt =3D false; + _Tp __sgn =3D _Tp(1); + _Tp __term =3D _Tp(0); + for (unsigned int __j =3D 0; __j <=3D __i; ++__j) + { + + _Tp __bincoeff =3D ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt =3D true; + break; + } + __bincoeff =3D std::exp(__bincoeff); + __term +=3D __sgn * __bincoeff * std::pow(_Tp(__a + __j), -_= _s); + __sgn *=3D _Tp(-1); + } + if (__punt) + break; + __term /=3D _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta +=3D __term; + } + + __zeta /=3D __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/include/c++/13/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 58 "/usr/include/c++/13/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 248 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 264 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 294 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 309 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 339 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 355 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 387 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 403 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 434 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 450 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 485 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 501 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 531 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 547 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 577 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 593 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 629 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 645 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 677 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 693 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 725 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 741 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 773 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 789 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 826 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __t= ype; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 841 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 866 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 882 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 914 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 930 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 958 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 974 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1003 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1019 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1054 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1070 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1098 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1114 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1125 "/usr/include/c++/13/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1145 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1161 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1189 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1216 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1292 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1303 "/usr/include/c++/13/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1323 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __t= ype; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1340 "/usr/include/c++/13/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1351 "/usr/include/c++/13/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double _= _x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1372 "/usr/include/c++/13/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} +# 3717 "/usr/include/c++/13/cmath" 2 3 + + +} +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" 2 + + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" 1 +# 29 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +# 1 "/usr/include/c++/13/math.h" 1 3 +# 36 "/usr/include/c++/13/math.h" 3 +# 1 "/usr/include/c++/13/cmath" 1 3 +# 39 "/usr/include/c++/13/cmath" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cmath" 3 +# 37 "/usr/include/c++/13/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 30 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" 2 + + + + + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/set_macros-inl.= h" 1 +# 36 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" 2 + + +# 37 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +static_assert(true, "For requiring trailing semicolon"); +namespace hwy { +namespace N_EMU128 { +# 55 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +using VecArg =3D V; + + +namespace detail { + + + +constexpr size_t ScaleByPower(size_t N, int pow2) { + return pow2 >=3D 0 ? (N << pow2) : (N >> (-pow2)); +} + +} +# 103 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +struct Simd { + constexpr Simd() =3D default; + using T =3D Lane; + + private: + static_assert(sizeof(Lane) <=3D 8, "Lanes are up to 64-bit"); + + + static constexpr size_t kWhole =3D N & 0xFFFFF; + + static constexpr int kFrac =3D static_cast(N >> 20); + + + static_assert(kWhole <=3D 8 * 65536 && kFrac <=3D 3, "Out of range"); + static_assert(kFrac =3D=3D 0 || kWhole =3D=3D 1, "If frac, whole must be= 1"); + static_assert((kWhole & (kWhole - 1)) =3D=3D 0 && kWhole !=3D 0, "Not 2^= x"); + + + static_assert(kPow2 >=3D -8, "Forgot kPow2 recursion terminator?"); + + + + + public: +# 142 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" + static constexpr size_t kPrivateLanes =3D + ((size_t{1}) > (detail::ScaleByPower(kWhole, kPow2 - kFrac)) ? (size= _t{1}) : (detail::ScaleByPower(kWhole, kPow2 - kFrac))); + + constexpr size_t MaxLanes() const { return kPrivateLanes; } + constexpr size_t MaxBytes() const { return kPrivateLanes * sizeof(Lane);= } + + constexpr int Pow2() const { return kPow2; } + + + + + + + template + static constexpr size_t RepartitionLanes() { + + return (kPrivateLanes * sizeof(T) + sizeof(NewT) - 1) / sizeof(NewT); + } + + + template + static constexpr int RebindPow2() { + return kPow2 + + ((sizeof(NewT) >=3D sizeof(T)) + ? static_cast(CeilLog2(sizeof(NewT) / sizeof(T))) + : -static_cast(CeilLog2(sizeof(T) / sizeof(NewT)))); + } + + private: + + template + static constexpr size_t WholeN() { + return detail::ScaleByPower(kNewMaxLanes, -kNewPow2); + } + + + template + static constexpr size_t FracN() { + + + + + static_assert(65536 <=3D (size_t{1} << 20), "Change bit shift"); + return static_cast( + 1 + (((0) > (kNewPow2 - static_cast(CeilLog2(kNewMaxLanes))) = ? (0) : (kNewPow2 - static_cast(CeilLog2(kNewMaxLanes)))) + << 20)); + } + + public: + + template + static constexpr size_t NewN() { + + return WholeN() =3D=3D 0 + ? FracN() + : WholeN(); + } + + + template + using Rebind =3D + Simd(), kPrivateLanes>(), RebindPow2()>; + + + template + using Repartition =3D + Simd()>(), kPow2>; + + + using Half =3D Simd; + + + using Twice =3D Simd; +}; + +namespace detail { + +template +constexpr bool IsFull(Simd ) { + return N =3D=3D (16 / sizeof(T)) && kPow2 =3D=3D 0; +} + + +template +struct ClampNAndPow2 { + using type =3D Simd; +}; + +template +struct ScalableTagChecker { + using type =3D typename ClampNAndPow2::type; +}; + +template +struct CappedTagChecker { + static_assert(kLimit !=3D 0, "Does not make sense to have zero lanes"); + + + static constexpr size_t kLimitPow2 =3D size_t{1} << hwy::FloorLog2(kLimi= t); + static constexpr size_t N =3D ((kLimitPow2) < ((16 / sizeof(T))) ? (kLim= itPow2) : ((16 / sizeof(T)))); + using type =3D typename ClampNAndPow2::type; +}; + +template +struct FixedTagChecker { + static_assert(kNumLanes !=3D 0, "Does not make sense to have zero lanes"= ); + static_assert(kNumLanes <=3D (16 / sizeof(T)), "Too many lanes"); + using type =3D Simd; +}; + +} +# 261 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +using ScalableTag =3D typename detail::ScalableTagChecker::type; +# 273 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +using CappedTag =3D typename detail::CappedTagChecker::t= ype; +# 289 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +using FixedTag =3D typename detail::FixedTagChecker::type; + + +template +using Full16 =3D Simd; + +template +using Full32 =3D Simd; + +template +using Full64 =3D Simd; + +template +using Full128 =3D Simd; + + + + +template +using TFromD =3D typename D::T; +# 320 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +template +inline __attribute__((always_inline)) __attribute__((unused)) constexpr si= ze_t MaxLanes(D) { + return D::kPrivateLanes; +} + + + + + + +template +inline __attribute__((always_inline)) __attribute__((unused)) constexpr si= ze_t Lanes(D) { + return D::kPrivateLanes; +} + + + + +template +using Rebind =3D typename D::template Rebind; + +template +using RebindToSigned =3D Rebind>, D>; +template +using RebindToUnsigned =3D Rebind>, D>; +template +using RebindToFloat =3D Rebind>, D>; + + +template +using Repartition =3D typename D::template Repartition; + +template +using RepartitionToWide =3D Repartition>, D>; +template +using RepartitionToNarrow =3D Repartition>, D>; + + +template +using Half =3D typename D::Half; + + +template +using Twice =3D typename D::Twice; +# 439 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/shared-inl.h" +} +} +static_assert(true, "For requiring trailing semicolon"); +# 25 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" 2 + +static_assert(true, "For requiring trailing semicolon"); +namespace hwy { +namespace N_EMU128 { + +template +using Full128 =3D Simd; + + +template +struct Vec128 { + using PrivateT =3D T; + static constexpr size_t kPrivateN =3D N; + + inline __attribute__((always_inline)) Vec128() =3D default; + Vec128(const Vec128&) =3D default; + Vec128& operator=3D(const Vec128&) =3D default; + + inline __attribute__((always_inline)) Vec128& operator*=3D(const Vec128 = other) { + return *this =3D (*this * other); + } + inline __attribute__((always_inline)) Vec128& operator/=3D(const Vec128 = other) { + return *this =3D (*this / other); + } + inline __attribute__((always_inline)) Vec128& operator+=3D(const Vec128 = other) { + return *this =3D (*this + other); + } + inline __attribute__((always_inline)) Vec128& operator-=3D(const Vec128 = other) { + return *this =3D (*this - other); + } + inline __attribute__((always_inline)) Vec128& operator&=3D(const Vec128 = other) { + return *this =3D (*this & other); + } + inline __attribute__((always_inline)) Vec128& operator|=3D(const Vec128 = other) { + return *this =3D (*this | other); + } + inline __attribute__((always_inline)) Vec128& operator^=3D(const Vec128 = other) { + return *this =3D (*this ^ other); + } + + + + + + + T raw[16 / sizeof(T)] =3D {}; +}; + + +template +struct Mask128 { + using Raw =3D hwy::MakeUnsigned; + static inline __attribute__((always_inline)) Raw FromBool(bool b) { + return b ? static_cast(~Raw{0}) : 0; + } + + + Raw bits[16 / sizeof(T)] =3D {}; +}; + +template +using DFromV =3D Simd; + +template +using TFromV =3D typename V::PrivateT; + + + + +template ) <=3D= 16>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128, D::kPrivateLanes> Zero(D ) { + Vec128, D::kPrivateLanes> v; + return v; +} + +template +using VFromD =3D decltype(Zero(D())); + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD BitCast(D , VFrom v) { + VFromD to; + CopySameSize(&v, &to); + return to; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Set(D d, const T2 t) { + VFromD v; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + v.raw[i] =3D static_cast>(t); + } + return v; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Undefined(D d) { + return Zero(d); +} + + + +template , typename T2> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Iota(D d, T2 first) { + VFromD v; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + v.raw[i] =3D + AddWithWraparound(hwy::IsFloatTag(), static_cast(first), i); + } + return v; +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Not(Vec128 v) { + const DFromV d; + const RebindToUnsigned du; + using TU =3D TFromD; + VFromD vu =3D BitCast(du, v); + for (size_t i =3D 0; i < N; ++i) { + vu.raw[i] =3D static_cast(~vu.raw[i]); + } + return BitCast(d, vu); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 And(Vec128 a, Vec128 b) { + const DFromV d; + const RebindToUnsigned du; + auto au =3D BitCast(du, a); + auto bu =3D BitCast(du, b); + for (size_t i =3D 0; i < N; ++i) { + au.raw[i] &=3D bu.raw[i]; + } + return BitCast(d, au); +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator&(Vec128 a, Vec128 b) { + return And(a, b); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 AndNot(Vec128 a, Vec128 b) { + return And(Not(a), b); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Or(Vec128 a, Vec128 b) { + const DFromV d; + const RebindToUnsigned du; + auto au =3D BitCast(du, a); + auto bu =3D BitCast(du, b); + for (size_t i =3D 0; i < N; ++i) { + au.raw[i] |=3D bu.raw[i]; + } + return BitCast(d, au); +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator|(Vec128 a, Vec128 b) { + return Or(a, b); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Xor(Vec128 a, Vec128 b) { + const DFromV d; + const RebindToUnsigned du; + auto au =3D BitCast(du, a); + auto bu =3D BitCast(du, b); + for (size_t i =3D 0; i < N; ++i) { + au.raw[i] ^=3D bu.raw[i]; + } + return BitCast(d, au); +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator^(Vec128 a, Vec128 b) { + return Xor(a, b); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Xor3(Vec128 x1, Vec128 x2, Vec= 128 x3) { + return Xor(x1, Xor(x2, x3)); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Or3(Vec128 o1, Vec128 o2, Vec1= 28 o3) { + return Or(o1, Or(o2, o3)); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 OrAnd(Vec128 o, Vec128 a1, Vec= 128 a2) { + return Or(o, And(a1, a2)); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 IfVecThenElse(Vec128 mask, Vec128 yes, + Vec128 no) { + return Or(And(mask, yes), AndNot(mask, no)); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 CopySign(Vec128 magn, Vec128 s= ign) { + static_assert(IsFloat(), "Only makes sense for floating-point"); + const DFromV d; + const auto msb =3D SignBit(d); + return Or(AndNot(msb, magn), And(msb, sign)); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 CopySignToAbs(Vec128 abs, Vec128 sign) { + static_assert(IsFloat(), "Only makes sense for floating-point"); + const DFromV d; + return Or(abs, And(SignBit(d), sign)); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 BroadcastSignBit(Vec128 v) { + + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D v.raw[i] < 0 ? T(-1) : T(0); + } + return v; +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 MaskFromVec(Vec128 v) { + Mask128 mask; + CopySameSize(&v, &mask); + return mask; +} + +template +using MFromD =3D decltype(MaskFromVec(VFromD())); + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD RebindMask(DTo , MFrom mask) { + MFromD to; + CopySameSize(&mask, &to); + return to; +} + +template +Vec128 VecFromMask(Mask128 mask) { + Vec128 v; + CopySameSize(&mask, &v); + return v; +} + +template +VFromD VecFromMask(D , MFromD mask) { + return VecFromMask(mask); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD FirstN(D d, size_t n) { + MFromD m; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + m.bits[i] =3D MFromD::FromBool(i < n); + } + return m; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 IfThenElse(Mask128 mask, Vec128 yes, + Vec128 no) { + return IfVecThenElse(VecFromMask(mask), yes, no); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 IfThenElseZero(Mask128 mask, Vec128<= T, N> yes) { + const DFromV d; + return IfVecThenElse(VecFromMask(mask), yes, Zero(d)); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 IfThenZeroElse(Mask128 mask, Vec128<= T, N> no) { + const DFromV d; + return IfVecThenElse(VecFromMask(mask), Zero(d), no); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 IfNegativeThenElse(Vec128 v, Vec128<= T, N> yes, + Vec128 no) { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D v.raw[i] < 0 ? yes.raw[i] : no.raw[i]; + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ZeroIfNegative(Vec128 v) { + const DFromV d; + return IfNegativeThenElse(v, Zero(d), v); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 Not(Mask128 m) { + return MaskFromVec(Not(VecFromMask(Simd(), m))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 And(Mask128 a, Mask128 b) { + const Simd d; + return MaskFromVec(And(VecFromMask(d, a), VecFromMask(d, b))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 AndNot(Mask128 a, Mask128 b) { + const Simd d; + return MaskFromVec(AndNot(VecFromMask(d, a), VecFromMask(d, b))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 Or(Mask128 a, Mask128 b) { + const Simd d; + return MaskFromVec(Or(VecFromMask(d, a), VecFromMask(d, b))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 Xor(Mask128 a, Mask128 b) { + const Simd d; + return MaskFromVec(Xor(VecFromMask(d, a), VecFromMask(d, b))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 ExclusiveNeither(Mask128 a, Mask128= b) { + const Simd d; + return MaskFromVec(AndNot(VecFromMask(d, a), Not(VecFromMask(d, b)))); +} + + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftLeft(Vec128 v) { + static_assert(0 <=3D kBits && kBits < sizeof(T) * 8, "Invalid shift"); + for (size_t i =3D 0; i < N; ++i) { + const auto shifted =3D static_cast>(v.raw[i]) << = kBits; + v.raw[i] =3D static_cast(shifted); + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftRight(Vec128 v) { + static_assert(0 <=3D kBits && kBits < sizeof(T) * 8, "Invalid shift"); + + + + + + + + if (IsSigned()) { + + + using TU =3D hwy::MakeUnsigned; + for (size_t i =3D 0; i < N; ++i) { + const TU shifted =3D static_cast(static_cast(v.raw[i]) >> kB= its); + const TU sign =3D v.raw[i] < 0 ? static_cast(~TU{0}) : 0; + const size_t sign_shift =3D + static_cast(static_cast(sizeof(TU)) * 8 - 1 - kBits= ); + const TU upper =3D static_cast(sign << sign_shift); + v.raw[i] =3D static_cast(shifted | upper); + } + } else { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D static_cast(v.raw[i] >> kBits); + } + } + + return v; +} + + + +namespace detail { + + +template +struct RotateRight { + template + inline __attribute__((always_inline)) Vec128 operator()(Vec128 v) const { + return Or(ShiftRight(v), ShiftLeft(v)); + } +}; + +template <> +struct RotateRight<0> { + template + inline __attribute__((always_inline)) Vec128 operator()(Vec128 v) const { + return v; + } +}; + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 RotateRight(Vec128 v) { + static_assert(0 <=3D kBits && kBits < sizeof(T) * 8, "Invalid shift"); + return detail::RotateRight()(v); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftLeftSame(Vec128 v, int bits) { + for (size_t i =3D 0; i < N; ++i) { + const auto shifted =3D static_cast>(v.raw[i]) << = bits; + v.raw[i] =3D static_cast(shifted); + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftRightSame(Vec128 v, int bits) { + + + + + + + + if (IsSigned()) { + + + using TU =3D hwy::MakeUnsigned; + for (size_t i =3D 0; i < N; ++i) { + const TU shifted =3D static_cast(static_cast(v.raw[i]) >> bi= ts); + const TU sign =3D v.raw[i] < 0 ? static_cast(~TU{0}) : 0; + const size_t sign_shift =3D + static_cast(static_cast(sizeof(TU)) * 8 - 1 - bits); + const TU upper =3D static_cast(sign << sign_shift); + v.raw[i] =3D static_cast(shifted | upper); + } + } else { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D static_cast(v.raw[i] >> bits); + } + } + + return v; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator<<(Vec128 v, Vec128 bi= ts) { + for (size_t i =3D 0; i < N; ++i) { + const auto shifted =3D static_cast>(v.raw[i]) + << bits.raw[i]; + v.raw[i] =3D static_cast(shifted); + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator>>(Vec128 v, Vec128 bi= ts) { + + + + + + + + if (IsSigned()) { + + + using TU =3D hwy::MakeUnsigned; + for (size_t i =3D 0; i < N; ++i) { + const TU shifted =3D + static_cast(static_cast(v.raw[i]) >> bits.raw[i]); + const TU sign =3D v.raw[i] < 0 ? static_cast(~TU{0}) : 0; + const size_t sign_shift =3D static_cast( + static_cast(sizeof(TU)) * 8 - 1 - bits.raw[i]); + const TU upper =3D static_cast(sign << sign_shift); + v.raw[i] =3D static_cast(shifted | upper); + } + } else { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D static_cast(v.raw[i] >> bits.raw[i]); + } + } + + return v; +} + + + + +namespace detail { + +template +inline __attribute__((always_inline)) Vec128 Add(hwy::NonFloatTag , = Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + const uint64_t a64 =3D static_cast(a.raw[i]); + const uint64_t b64 =3D static_cast(b.raw[i]); + a.raw[i] =3D static_cast((a64 + b64) & static_cast(~T(0))= ); + } + return a; +} +template +inline __attribute__((always_inline)) Vec128 Sub(hwy::NonFloatTag , = Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + const uint64_t a64 =3D static_cast(a.raw[i]); + const uint64_t b64 =3D static_cast(b.raw[i]); + a.raw[i] =3D static_cast((a64 - b64) & static_cast(~T(0))= ); + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Add(hwy::FloatTag , Vec= 128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] +=3D b.raw[i]; + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Sub(hwy::FloatTag , Vec= 128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] -=3D b.raw[i]; + } + return a; +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator-(Vec128 a, Vec128 b) { + return detail::Sub(hwy::IsFloatTag(), a, b); +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator+(Vec128 a, Vec128 b) { + return detail::Add(hwy::IsFloatTag(), a, b); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 SumsOf8(Vec128 v) { + Vec128 sums; + for (size_t i =3D 0; i < N; ++i) { + sums.raw[i / 8] +=3D v.raw[i]; + } + return sums; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 SaturatedAdd(Vec128 a, Vec128 = b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast( + ((((hwy::LowestValue()) > (a.raw[i] + b.raw[i]) ? (hwy::LowestV= alue()) : (a.raw[i] + b.raw[i]))) < (hwy::HighestValue()) ? (((hwy::L= owestValue()) > (a.raw[i] + b.raw[i]) ? (hwy::LowestValue()) : (a.raw= [i] + b.raw[i]))) : (hwy::HighestValue())) + ); + } + return a; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 SaturatedSub(Vec128 a, Vec128 = b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast( + ((((hwy::LowestValue()) > (a.raw[i] - b.raw[i]) ? (hwy::LowestV= alue()) : (a.raw[i] - b.raw[i]))) < (hwy::HighestValue()) ? (((hwy::L= owestValue()) > (a.raw[i] - b.raw[i]) ? (hwy::LowestValue()) : (a.raw= [i] - b.raw[i]))) : (hwy::HighestValue())) + ); + } + return a; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 AverageRound(Vec128 a, Vec128 = b) { + static_assert(!IsSigned(), "Only for unsigned"); + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast((a.raw[i] + b.raw[i] + 1) / 2); + } + return a; +} + + + + +namespace detail { + +template +inline __attribute__((always_inline)) Vec128 Abs(SignedTag , Vec128<= T, N> a) { + for (size_t i =3D 0; i < N; ++i) { + const T s =3D a.raw[i]; + const T min =3D hwy::LimitsMin(); + a.raw[i] =3D static_cast((s >=3D 0 || s =3D=3D min) ? a.raw[i] : -s= ); + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Abs(hwy::FloatTag , Vec= 128 v) { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D std::abs(v.raw[i]); + } + return v; +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Abs(Vec128 a) { + return detail::Abs(hwy::TypeTag(), a); +} + + + + +namespace detail { + +template +inline __attribute__((always_inline)) Vec128 Min(hwy::NonFloatTag , = Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D ((a.raw[i]) < (b.raw[i]) ? (a.raw[i]) : (b.raw[i])); + } + return a; +} +template +inline __attribute__((always_inline)) Vec128 Max(hwy::NonFloatTag , = Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D ((a.raw[i]) > (b.raw[i]) ? (a.raw[i]) : (b.raw[i])); + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Min(hwy::FloatTag , Vec= 128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + if (std::isnan(a.raw[i])) { + a.raw[i] =3D b.raw[i]; + } else if (std::isnan(b.raw[i])) { + + } else { + a.raw[i] =3D ((a.raw[i]) < (b.raw[i]) ? (a.raw[i]) : (b.raw[i])); + } + } + return a; +} +template +inline __attribute__((always_inline)) Vec128 Max(hwy::FloatTag , Vec= 128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + if (std::isnan(a.raw[i])) { + a.raw[i] =3D b.raw[i]; + } else if (std::isnan(b.raw[i])) { + + } else { + a.raw[i] =3D ((a.raw[i]) > (b.raw[i]) ? (a.raw[i]) : (b.raw[i])); + } + } + return a; +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Min(Vec128 a, Vec128 b) { + return detail::Min(hwy::IsFloatTag(), a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Max(Vec128 a, Vec128 b) { + return detail::Max(hwy::IsFloatTag(), a, b); +} + + + + +namespace detail { + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Neg(hwy::NonFloatTag , Vec128 v) { + const DFromV d; + return Zero(d) - v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Neg(hwy::FloatTag , Vec128 v) { + const DFromV d; + return Xor(v, SignBit(d)); +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Neg(Vec128 v) { + return detail::Neg(hwy::IsFloatTag(), v); +} + + + + +namespace detail { + +template +inline __attribute__((always_inline)) Vec128 Mul(hwy::FloatTag , Vec= 128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] *=3D b.raw[i]; + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Mul(SignedTag , Vec128<= T, N> a, Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast(static_cast(a.raw[i]) * + static_cast(b.raw[i])); + } + return a; +} + +template +inline __attribute__((always_inline)) Vec128 Mul(UnsignedTag , Vec12= 8 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast(static_cast(a.raw[i]) * + static_cast(b.raw[i])); + } + return a; +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator*(Vec128 a, Vec128 b) { + return detail::Mul(hwy::TypeTag(), a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 operator/(Vec128 a, Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D (b.raw[i] =3D=3D T{0}) ? 0 : a.raw[i] / b.raw[i]; + } + return a; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulHigh(Vec128 a, Vec128= b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast((int32_t{a.raw[i]} * b.raw[i]) >> 16= ); + } + return a; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulHigh(Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + + + + a.raw[i] =3D static_cast( + (static_cast(a.raw[i]) * static_cast(b.raw[i])= ) >> + 16); + } + return a; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulFixedPoint15(Vec128 a, + Vec128 b) { + for (size_t i =3D 0; i < N; ++i) { + a.raw[i] =3D static_cast((2 * a.raw[i] * b.raw[i] + 32768) >>= 16); + } + return a; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulEven(Vec128= a, + Vec128 b) { + Vec128 mul; + for (size_t i =3D 0; i < N; i +=3D 2) { + const int64_t a64 =3D a.raw[i]; + mul.raw[i / 2] =3D a64 * b.raw[i]; + } + return mul; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulEven(Vec128 a, + Vec128 b) { + Vec128 mul; + for (size_t i =3D 0; i < N; i +=3D 2) { + const uint64_t a64 =3D a.raw[i]; + mul.raw[i / 2] =3D a64 * b.raw[i]; + } + return mul; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulOdd(Vec128 = a, + Vec128 b) { + Vec128 mul; + for (size_t i =3D 0; i < N; i +=3D 2) { + const int64_t a64 =3D a.raw[i + 1]; + mul.raw[i / 2] =3D a64 * b.raw[i + 1]; + } + return mul; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulOdd(Vec128 a, + Vec128 b) { + Vec128 mul; + for (size_t i =3D 0; i < N; i +=3D 2) { + const uint64_t a64 =3D a.raw[i + 1]; + mul.raw[i / 2] =3D a64 * b.raw[i + 1]; + } + return mul; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ApproximateReciprocal(Vec128= v) { + for (size_t i =3D 0; i < N; ++i) { + + + + v.raw[i] =3D (std::abs(v.raw[i]) =3D=3D 0.0f) ? 0.0f : 1.0f / v.raw[i]; + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 AbsDiff(Vec128 a, Vec128 b) { + return Abs(a - b); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulAdd(Vec128 mul, Vec128 x, + Vec128 add) { + return mul * x + add; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 NegMulAdd(Vec128 mul, Vec128 x, + Vec128 add) { + return add - mul * x; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 MulSub(Vec128 mul, Vec128 x, + Vec128 sub) { + return mul * x - sub; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 NegMulSub(Vec128 mul, Vec128 x, + Vec128 sub) { + return Neg(mul) * x - sub; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ApproximateReciprocalSqrt(Vec128 v) { + for (size_t i =3D 0; i < N; ++i) { + const float half =3D v.raw[i] * 0.5f; + uint32_t bits; + CopySameSize(&v.raw[i], &bits); + + bits =3D 0x5F3759DF - (bits >> 1); + CopySameSize(&bits, &v.raw[i]); + + v.raw[i] =3D v.raw[i] * (1.5f - (half * v.raw[i] * v.raw[i])); + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Sqrt(Vec128 v) { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D std::sqrt(v.raw[i]); + } + return v; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Round(Vec128 v) { + using TI =3D MakeSigned; + const Vec128 a =3D Abs(v); + for (size_t i =3D 0; i < N; ++i) { + if (!(a.raw[i] < MantissaEnd())) { + continue; + } + const T bias =3D v.raw[i] < T(0.0) ? T(-0.5) : T(0.5); + const TI rounded =3D static_cast(v.raw[i] + bias); + if (rounded =3D=3D 0) { + v.raw[i] =3D v.raw[i] < 0 ? T{-0} : T{0}; + continue; + } + const T rounded_f =3D static_cast(rounded); + + if ((rounded & 1) && std::abs(rounded_f - v.raw[i]) =3D=3D T(0.5)) { + v.raw[i] =3D static_cast(rounded - (v.raw[i] < T(0) ? -1 : 1)); + continue; + } + v.raw[i] =3D rounded_f; + } + return v; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 NearestInt(Vec128 v) { + using T =3D float; + using TI =3D int32_t; + + const Vec128 abs =3D Abs(v); + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + const bool signbit =3D std::signbit(v.raw[i]); + + if (!(abs.raw[i] < MantissaEnd())) { + + if (!(abs.raw[i] <=3D static_cast(LimitsMax()))) { + ret.raw[i] =3D signbit ? LimitsMin() : LimitsMax(); + continue; + } + ret.raw[i] =3D static_cast(v.raw[i]); + continue; + } + const T bias =3D v.raw[i] < T(0.0) ? T(-0.5) : T(0.5); + const TI rounded =3D static_cast(v.raw[i] + bias); + if (rounded =3D=3D 0) { + ret.raw[i] =3D 0; + continue; + } + const T rounded_f =3D static_cast(rounded); + + if ((rounded & 1) && std::abs(rounded_f - v.raw[i]) =3D=3D T(0.5)) { + ret.raw[i] =3D rounded - (signbit ? -1 : 1); + continue; + } + ret.raw[i] =3D rounded; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Trunc(Vec128 v) { + using TI =3D MakeSigned; + const Vec128 abs =3D Abs(v); + for (size_t i =3D 0; i < N; ++i) { + if (!(abs.raw[i] <=3D MantissaEnd())) { + continue; + } + const TI truncated =3D static_cast(v.raw[i]); + if (truncated =3D=3D 0) { + v.raw[i] =3D v.raw[i] < 0 ? -T{0} : T{0}; + continue; + } + v.raw[i] =3D static_cast(truncated); + } + return v; +} + + +template +Vec128 Ceil(Vec128 v) { + constexpr int kMantissaBits =3D MantissaBits(); + using Bits =3D MakeUnsigned; + const Bits kExponentMask =3D MaxExponentField(); + const Bits kMantissaMask =3D MantissaMask(); + const Bits kBias =3D kExponentMask / 2; + + for (size_t i =3D 0; i < N; ++i) { + const bool positive =3D v.raw[i] > Float(0.0); + + Bits bits; + CopySameSize(&v.raw[i], &bits); + + const int exponent =3D + static_cast(((bits >> kMantissaBits) & kExponentMask) - kBias= ); + + if (exponent >=3D kMantissaBits) continue; + + if (exponent < 0) { + v.raw[i] =3D positive ? Float{1} : Float{-0.0}; + continue; + } + + const Bits mantissa_mask =3D kMantissaMask >> exponent; + + if ((bits & mantissa_mask) =3D=3D 0) continue; + + + if (positive) bits +=3D (kMantissaMask + 1) >> exponent; + bits &=3D ~mantissa_mask; + + CopySameSize(&bits, &v.raw[i]); + } + return v; +} + + +template +Vec128 Floor(Vec128 v) { + constexpr int kMantissaBits =3D MantissaBits(); + using Bits =3D MakeUnsigned; + const Bits kExponentMask =3D MaxExponentField(); + const Bits kMantissaMask =3D MantissaMask(); + const Bits kBias =3D kExponentMask / 2; + + for (size_t i =3D 0; i < N; ++i) { + const bool negative =3D v.raw[i] < Float(0.0); + + Bits bits; + CopySameSize(&v.raw[i], &bits); + + const int exponent =3D + static_cast(((bits >> kMantissaBits) & kExponentMask) - kBias= ); + + if (exponent >=3D kMantissaBits) continue; + + if (exponent < 0) { + v.raw[i] =3D negative ? Float(-1.0) : Float(0.0); + continue; + } + + const Bits mantissa_mask =3D kMantissaMask >> exponent; + + if ((bits & mantissa_mask) =3D=3D 0) continue; + + + if (negative) bits +=3D (kMantissaMask + 1) >> exponent; + bits &=3D ~mantissa_mask; + + CopySameSize(&bits, &v.raw[i]); + } + return v; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 IsNaN(Vec128 v) { + Mask128 ret; + for (size_t i =3D 0; i < N; ++i) { + + MakeUnsigned bits; + CopySameSize(&v.raw[i], &bits); + bits +=3D bits; + bits >>=3D 1; + + ret.bits[i] =3D Mask128::FromBool(bits > ExponentMask()); + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 IsInf(Vec128 v) { + static_assert(IsFloat(), "Only for float"); + const DFromV d; + const RebindToSigned di; + const VFromD vi =3D BitCast(di, v); + + return RebindMask(d, Eq(Add(vi, vi), Set(di, hwy::MaxExponentTimes2()= ))); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 IsFinite(Vec128 v) { + static_assert(IsFloat(), "Only for float"); + const DFromV d; + const RebindToUnsigned du; + const RebindToSigned di; + using VI =3D VFromD; + using VU =3D VFromD; + const VU vu =3D BitCast(du, v); + + + + const VI exp =3D + BitCast(di, ShiftRight() + 1>(Add(vu, vu))); + return RebindMask(d, Lt(exp, Set(di, hwy::MaxExponentField()))); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator=3D=3D(Vec128 a, Vec128 b) { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] =3D=3D b.raw[i]); + } + return m; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator!=3D(Vec128 a, Vec128= b) { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] !=3D b.raw[i]); + } + return m; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 TestBit(Vec128 v, Vec128 bit)= { + static_assert(!hwy::IsFloat(), "Only integer vectors supported"); + return (v & bit) =3D=3D bit; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator<(Vec128 a, Vec128 b)= { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] < b.raw[i]); + } + return m; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator>(Vec128 a, Vec128 b)= { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] > b.raw[i]); + } + return m; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator<=3D(Vec128 a, Vec128= b) { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] <=3D b.raw[i]); + } + return m; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 operator>=3D(Vec128 a, Vec128= b) { + Mask128 m; + for (size_t i =3D 0; i < N; ++i) { + m.bits[i] =3D Mask128::FromBool(a.raw[i] >=3D b.raw[i]); + } + return m; +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD Lt128(D , Vec128 a, Vec128 b) { + const bool lt =3D + (a.raw[1] < b.raw[1]) || (a.raw[1] =3D=3D b.raw[1] && a.raw[0] < b.r= aw[0]); + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(lt); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD Lt128Upper(D , Vec128 a, + Vec128 b) { + const bool lt =3D a.raw[1] < b.raw[1]; + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(lt); + return ret; +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD Eq128(D , Vec128 a, Vec128 b) { + const bool eq =3D a.raw[1] =3D=3D b.raw[1] && a.raw[0] =3D=3D b.raw[0]; + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(eq); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Mask128 Ne128(D , Vec128 a, + Vec128 b) { + const bool ne =3D a.raw[1] !=3D b.raw[1] || a.raw[0] !=3D b.raw[0]; + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(ne); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD Eq128Upper(D , Vec128 a, + Vec128 b) { + const bool eq =3D a.raw[1] =3D=3D b.raw[1]; + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(eq); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD Ne128Upper(D , Vec128 a, + Vec128 b) { + const bool ne =3D a.raw[1] !=3D b.raw[1]; + Mask128 ret; + ret.bits[0] =3D ret.bits[1] =3D Mask128::FromBool(ne); + return ret; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Min128(D d, VFromD a, VFromD b) { + return IfThenElse(Lt128(d, a, b), a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Max128(D d, VFromD a, VFromD b) { + return IfThenElse(Lt128(d, b, a), a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Min128Upper(D d, VFromD a, VFromD b) { + return IfThenElse(Lt128Upper(d, a, b), a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Max128Upper(D d, VFromD a, VFromD b) { + return IfThenElse(Lt128Upper(d, b, a), a, b); +} + + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Load(D d, const TFromD* __restrict__ align= ed) { + VFromD v; + CopyBytes(aligned, v.raw); + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD MaskedLoad(MFromD m, D d, + const TFromD* __restrict__ p) { + return IfThenElseZero(m, LoadU(d, p)); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD LoadU(D d, const TFromD* __restrict__ p) { + return Load(d, p); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD LoadDup128(D d, const TFromD* __restrict__= aligned) { + return Load(d, aligned); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void Store(VFromD v, D d, TFromD* __restrict__ al= igned) { + CopyBytes(v.raw, aligned); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void StoreU(VFromD v, D d, TFromD* __restrict__ p= ) { + Store(v, d, p); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void BlendedStore(VFromD v, MFromD m, D d, + TFromD* __restrict__ p) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + if (m.bits[i]) p[i] =3D v.raw[i]; + } +} +# 1340 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void LoadInterleaved2(D d, const T* __restrict__ unalig= ned, + VFromD& v0, VFromD& v1) { + alignas(16) T buf0[MaxLanes(d)]; + alignas(16) T buf1[MaxLanes(d)]; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + buf0[i] =3D *unaligned++; + buf1[i] =3D *unaligned++; + } + v0 =3D Load(d, buf0); + v1 =3D Load(d, buf1); +} + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void LoadInterleaved3(D d, const T* __restrict__ unalig= ned, + VFromD& v0, VFromD& v1, VFromD& v2)= { + alignas(16) T buf0[MaxLanes(d)]; + alignas(16) T buf1[MaxLanes(d)]; + alignas(16) T buf2[MaxLanes(d)]; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + buf0[i] =3D *unaligned++; + buf1[i] =3D *unaligned++; + buf2[i] =3D *unaligned++; + } + v0 =3D Load(d, buf0); + v1 =3D Load(d, buf1); + v2 =3D Load(d, buf2); +} + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void LoadInterleaved4(D d, const T* __restrict__ unalig= ned, + VFromD& v0, VFromD& v1, VFromD& v2, + VFromD& v3) { + alignas(16) T buf0[MaxLanes(d)]; + alignas(16) T buf1[MaxLanes(d)]; + alignas(16) T buf2[MaxLanes(d)]; + alignas(16) T buf3[MaxLanes(d)]; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + buf0[i] =3D *unaligned++; + buf1[i] =3D *unaligned++; + buf2[i] =3D *unaligned++; + buf3[i] =3D *unaligned++; + } + v0 =3D Load(d, buf0); + v1 =3D Load(d, buf1); + v2 =3D Load(d, buf2); + v3 =3D Load(d, buf3); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void StoreInterleaved2(VFromD v0, VFromD v1, D d, + TFromD* __restrict__ unaligned) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + *unaligned++ =3D v0.raw[i]; + *unaligned++ =3D v1.raw[i]; + } +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void StoreInterleaved3(VFromD v0, VFromD v1, VFro= mD v2, D d, + TFromD* __restrict__ unaligned) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + *unaligned++ =3D v0.raw[i]; + *unaligned++ =3D v1.raw[i]; + *unaligned++ =3D v2.raw[i]; + } +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void StoreInterleaved4(VFromD v0, VFromD v1, VFro= mD v2, + VFromD v3, D d, + TFromD* __restrict__ unaligned) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + *unaligned++ =3D v0.raw[i]; + *unaligned++ =3D v1.raw[i]; + *unaligned++ =3D v2.raw[i]; + *unaligned++ =3D v3.raw[i]; + } +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void Stream(VFromD v, D d, TFromD* __restrict__ a= ligned) { + Store(v, d, aligned); +} + + + +template , typename Offset> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void ScatterOffset(VFromD v, D d, T* base, + Vec128 offset) { + static_assert(sizeof(T) =3D=3D sizeof(Offset), "Index/lane size must mat= ch"); + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + uint8_t* const base8 =3D reinterpret_cast(base) + offset.raw= [i]; + CopyBytes(&v.raw[i], base8); + } +} + +template , typename Index> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void ScatterIndex(VFromD v, D d, T* __restrict__ bas= e, + Vec128 index) { + static_assert(sizeof(T) =3D=3D sizeof(Index), "Index/lane size must matc= h"); + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + base[index.raw[i]] =3D v.raw[i]; + } +} + + + +template , typename Offset> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD GatherOffset(D d, const T* base, + Vec128 offset) { + static_assert(sizeof(T) =3D=3D sizeof(Offset), "Index/lane size must mat= ch"); + VFromD v; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + const uint8_t* base8 =3D + reinterpret_cast(base) + offset.raw[i]; + CopyBytes(base8, &v.raw[i]); + } + return v; +} + +template , typename Index> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD GatherIndex(D d, const T* __restrict__ base, + Vec128 index) { + static_assert(sizeof(T) =3D=3D sizeof(Index), "Index/lane size must matc= h"); + VFromD v; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + v.raw[i] =3D base[index.raw[i]]; + } + return v; +} + + + + + + +template ()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD PromoteTo(DTo d, Vec128 from) { + static_assert(sizeof(TFromD) > sizeof(TFrom), "Not promoting"); + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + + ret.raw[i] =3D static_cast>(from.raw[i]); + } + return ret; +} + + + +template , float>()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD DemoteTo(D d, VFromD> from)= { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + + if (std::isinf(from.raw[i]) || + std::fabs(from.raw[i]) > static_cast(HighestValue()= )) { + ret.raw[i] =3D std::signbit(from.raw[i]) ? LowestValue() + : HighestValue(); + continue; + } + ret.raw[i] =3D static_cast(from.raw[i]); + } + return ret; +} +template , int32_t>()>* =3D nullpt= r> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD DemoteTo(D d, VFromD> from)= { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + + if (std::isinf(from.raw[i]) || + std::fabs(from.raw[i]) > static_cast(HighestValue= ())) { + ret.raw[i] =3D std::signbit(from.raw[i]) ? LowestValue() + : HighestValue(); + continue; + } + ret.raw[i] =3D static_cast(from.raw[i]); + } + return ret; +} + +template ()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD DemoteTo(DTo , Vec128 from) { + using TTo =3D TFromD; + static_assert(sizeof(TTo) < sizeof(TFrom), "Not demoting"); + + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + + from.raw[i] =3D + ((((LimitsMin()) > (from.raw[i]) ? (LimitsMin()) : (from= .raw[i]))) < (LimitsMax()) ? (((LimitsMin()) > (from.raw[i]) ? (L= imitsMin()) : (from.raw[i]))) : (LimitsMax())); + ret.raw[i] =3D static_cast(from.raw[i]); + } + return ret; +} + +template , bfloat16_t>()>*= =3D nullptr, class VF32> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ReorderDemote2To(DBF16 dbf16, VF32 a, VF3= 2 b) { + const Repartition du32; + const VFromD b_in_lower =3D ShiftRight<16>(BitCast(du32,= b)); + + const VFromD a_mask =3D Set(du32, 0xFFFF0000); + return BitCast(dbf16, IfVecThenElse(a_mask, BitCast(du32, a), b_in_lower= )); +} + +template , int16_t>()>* =3D = nullptr, class VI32> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ReorderDemote2To(DI16 di16, VI32 a, VI32 b= ) { + const RepartitionToWide di32; + const size_t N32 =3D Lanes(di32); + const int16_t min =3D LimitsMin(); + const int16_t max =3D LimitsMax(); + VFromD ret; + for (size_t i =3D 0; i < N32; ++i) { + ret.raw[i] =3D static_cast(((((min) > (a.raw[i]) ? (min) : (a= .raw[i]))) < (max) ? (((min) > (a.raw[i]) ? (min) : (a.raw[i]))) : (max))); + } + for (size_t i =3D 0; i < N32; ++i) { + ret.raw[N32 + i] =3D + static_cast(((((min) > (b.raw[i]) ? (min) : (b.raw[i]))) = < (max) ? (((min) > (b.raw[i]) ? (min) : (b.raw[i]))) : (max))); + } + return ret; +} + +namespace detail { + +inline __attribute__((always_inline)) void StoreU16ToF16(const uint16_t va= l, + hwy::float16_t* __restrict__ to) { + CopySameSize(&val, to); +} + +inline __attribute__((always_inline)) uint16_t U16FromF16(const hwy::float= 16_t* __restrict__ from) { + uint16_t bits16; + CopySameSize(from, &bits16); + return bits16; +} + +} + +template , float>()>* =3D nullptr,= size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD PromoteTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + const uint16_t bits16 =3D detail::U16FromF16(&v.raw[i]); + const uint32_t sign =3D static_cast(bits16 >> 15); + const uint32_t biased_exp =3D (bits16 >> 10) & 0x1F; + const uint32_t mantissa =3D bits16 & 0x3FF; + + + if (biased_exp =3D=3D 0) { + const float subnormal =3D + (1.0f / 16384) * (static_cast(mantissa) * (1.0f / 1024)); + ret.raw[i] =3D sign ? -subnormal : subnormal; + continue; + } + + + + const uint32_t biased_exp32 =3D biased_exp + (127 - 15); + const uint32_t mantissa32 =3D mantissa << (23 - 10); + const uint32_t bits32 =3D (sign << 31) | (biased_exp32 << 23) | mantis= sa32; + CopySameSize(&bits32, &ret.raw[i]); + } + return ret; +} + +template , float>()>* =3D nullptr,= size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD PromoteTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D F32FromBF16(v.raw[i]); + } + return ret; +} + +template , float16_t>()>* =3D null= ptr, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD DemoteTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + uint32_t bits32; + CopySameSize(&v.raw[i], &bits32); + const uint32_t sign =3D bits32 >> 31; + const uint32_t biased_exp32 =3D (bits32 >> 23) & 0xFF; + const uint32_t mantissa32 =3D bits32 & 0x7FFFFF; + + const int32_t exp =3D ((static_cast(biased_exp32) - 127) < (1= 5) ? (static_cast(biased_exp32) - 127) : (15)); + + + if (exp < -24) { + ZeroBytes(&ret.raw[i]); + continue; + } + + uint32_t biased_exp16, mantissa16; + + + if (exp < -14) { + biased_exp16 =3D 0; + const uint32_t sub_exp =3D static_cast(-14 - exp); + do { } while (0); + mantissa16 =3D static_cast((1u << (10 - sub_exp)) + + (mantissa32 >> (13 + sub_exp))); + } else { + + biased_exp16 =3D static_cast(exp + 15); + do { } while (0); + mantissa16 =3D mantissa32 >> 13; + } + + do { } while (0); + const uint32_t bits16 =3D (sign << 15) | (biased_exp16 << 10) | mantis= sa16; + do { } while (0); + const uint16_t narrowed =3D static_cast(bits16); + detail::StoreU16ToF16(narrowed, &ret.raw[i]); + } + return ret; +} + +template , bfloat16_t>()>* =3D nul= lptr, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD DemoteTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D BF16FromF32(v.raw[i]); + } + return ret; +} + + +namespace detail { + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ConvertTo(hwy::FloatTag , + Simd , + Vec128 from) { + static_assert(sizeof(ToT) =3D=3D sizeof(TFrom), "Should have same size"); + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + + + const double f =3D static_cast(from.raw[i]); + if (std::isinf(from.raw[i]) || + std::fabs(f) > static_cast(LimitsMax())) { + ret.raw[i] =3D + std::signbit(from.raw[i]) ? LimitsMin() : LimitsMax(); + continue; + } + ret.raw[i] =3D static_cast(from.raw[i]); + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ConvertTo(hwy::NonFloatTag , + Simd , + Vec128 from) { + static_assert(sizeof(ToT) =3D=3D sizeof(TFrom), "Should have same size"); + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + + ret.raw[i] =3D static_cast(from.raw[i]); + } + return ret; +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConvertTo(DTo d, Vec128 from) { + return detail::ConvertTo(hwy::IsFloatTag(), d, from); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 U8FromU32(Vec128 v) { + return DemoteTo(Simd(), v); +} + + + +template , uint8_t>()>* =3D nullpt= r, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFF); + } + return ret; +} + +template , uint16_t>()>* =3D nullp= tr, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFFFF); + } + return ret; +} + +template , uint32_t>()>* =3D nullp= tr, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFFFFFFFFu); + } + return ret; +} + +template , uint8_t>()>* =3D nullpt= r, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFF); + } + return ret; +} + +template , uint16_t>()>* =3D nullp= tr, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFFFF); + } + return ret; +} + +template , uint8_t>()>* =3D nullpt= r, size_t N> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD TruncateTo(D , Vec128 v) { + VFromD ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D static_cast(v.raw[i] & 0xFF); + } + return ret; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 LowerHalf(Vec128 v) { + Vec128 ret; + CopyBytes(v.raw, ret.raw); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD LowerHalf(D , VFromD> v) { + return LowerHalf(v); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD UpperHalf(D d, VFromD> v) { + VFromD ret; + CopyBytes(&v.raw[MaxLanes(d)], ret.raw); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ZeroExtendVector(D d, VFromD> v) { + const Half dh; + VFromD ret; + CopyBytes(v.raw, ret.raw); + return ret; +} + +template >> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Combine(D d, VH hi_half, VH lo_half) { + const Half dh; + VFromD ret; + CopyBytes(lo_half.raw, &ret.raw[0]); + CopyBytes(hi_half.raw, &ret.raw[MaxLanes(dh)]); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatLowerLower(D d, VFromD hi, VFromD= lo) { + const Half dh; + VFromD ret; + CopyBytes(lo.raw, &ret.raw[0]); + CopyBytes(hi.raw, &ret.raw[MaxLanes(dh)]); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatUpperUpper(D d, VFromD hi, VFromD= lo) { + const Half dh; + VFromD ret; + CopyBytes(&lo.raw[MaxLanes(dh)], &ret.raw[0]); + CopyBytes(&hi.raw[MaxLanes(dh)], &ret.raw[MaxLanes(dh)]); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatLowerUpper(D d, VFromD hi, VFromD= lo) { + const Half dh; + VFromD ret; + CopyBytes(&lo.raw[MaxLanes(dh)], &ret.raw[0]); + CopyBytes(hi.raw, &ret.raw[MaxLanes(dh)]); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatUpperLower(D d, VFromD hi, VFromD= lo) { + const Half dh; + VFromD ret; + CopyBytes(lo.raw, &ret.raw[0]); + CopyBytes(&hi.raw[MaxLanes(dh)], &ret.raw[MaxLanes(dh)]); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatEven(D d, VFromD hi, VFromD lo) { + const Half dh; + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(dh); ++i) { + ret.raw[i] =3D lo.raw[2 * i]; + } + for (size_t i =3D 0; i < MaxLanes(dh); ++i) { + ret.raw[MaxLanes(dh) + i] =3D hi.raw[2 * i]; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ConcatOdd(D d, VFromD hi, VFromD lo) { + const Half dh; + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(dh); ++i) { + ret.raw[i] =3D lo.raw[2 * i + 1]; + } + for (size_t i =3D 0; i < MaxLanes(dh); ++i) { + ret.raw[MaxLanes(dh) + i] =3D hi.raw[2 * i + 1]; + } + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD CombineShiftRightBytes(D d, VFromD hi, VFr= omD lo) { + VFromD ret; + const uint8_t* __restrict__ lo8 =3D + reinterpret_cast(lo.raw); + uint8_t* __restrict__ ret8 =3D + reinterpret_cast(ret.raw); + CopyBytes(lo8 + kBytes, ret8); + CopyBytes(hi.raw, ret8 + d.MaxBytes() - kBytes); + return ret; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ShiftLeftBytes(D d, VFromD v) { + static_assert(0 <=3D kBytes && kBytes <=3D 16, "Invalid kBytes"); + VFromD ret; + uint8_t* __restrict__ ret8 =3D + reinterpret_cast(ret.raw); + ZeroBytes(ret8); + CopyBytes(v.raw, ret8 + kBytes); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftLeftBytes(Vec128 v) { + return ShiftLeftBytes(DFromV(), v); +} + + + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ShiftLeftLanes(D d, VFromD v) { + const Repartition d8; + return BitCast(d, ShiftLeftBytes(BitCast(d8, v))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 ShiftLeftLanes(Vec128 v) { + return ShiftLeftLanes(DFromV(), v); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ShiftRightBytes(D d, VFromD v) { + static_assert(0 <=3D kBytes && kBytes <=3D 16, "Invalid kBytes"); + VFromD ret; + const uint8_t* __restrict__ v8 =3D + reinterpret_cast(v.raw); + uint8_t* __restrict__ ret8 =3D + reinterpret_cast(ret.raw); + CopyBytes(v8 + kBytes, ret8); + ZeroBytes(ret8 + d.MaxBytes() - kBytes); + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ShiftRightLanes(D d, VFromD v) { + const Repartition d8; + constexpr size_t kBytes =3D kLanes * sizeof(TFromD); + return BitCast(d, ShiftRightBytes(d8, BitCast(d8, v))); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) T GetLane(Vec128 v) { + return v.raw[0]; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 InsertLane(Vec128 v, size_t i, T t) { + v.raw[i] =3D t; + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) T ExtractLane(Vec128 v, size_t i) { + return v.raw[i]; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 DupEven(Vec128 v) { + for (size_t i =3D 0; i < N; i +=3D 2) { + v.raw[i + 1] =3D v.raw[i]; + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 DupOdd(Vec128 v) { + for (size_t i =3D 0; i < N; i +=3D 2) { + v.raw[i] =3D v.raw[i + 1]; + } + return v; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 OddEven(Vec128 odd, Vec128 eve= n) { + for (size_t i =3D 0; i < N; i +=3D 2) { + odd.raw[i] =3D even.raw[i]; + } + return odd; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 OddEvenBlocks(Vec128 , Vec128 = even) { + return even; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 SwapAdjacentBlocks(Vec128 v) { + return v; +} + + + + +template +struct Indices128 { + MakeSigned raw[N]; +}; + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Indices128, N> IndicesFromVec(D d, Vec128 vec) { + static_assert(sizeof(TFromD) =3D=3D sizeof(TI), "Index/lane size must= match"); + Indices128, N> ret; + CopyBytes(vec.raw, ret.raw); + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Indices128, D::kPrivateLanes> SetTableIndices( + D d, const TI* idx) { + return IndicesFromVec(d, LoadU(Rebind(), idx)); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 TableLookupLanes(Vec128 v, Indices12= 8 idx) { + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + ret.raw[i] =3D v.raw[idx.raw[i]]; + } + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ReverseBlocks(D , VFromD v) { + return v; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Reverse(D d, VFromD v) { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + ret.raw[i] =3D v.raw[MaxLanes(d) - 1 - i]; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Reverse2(D d, VFromD v) { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); i +=3D 2) { + ret.raw[i + 0] =3D v.raw[i + 1]; + ret.raw[i + 1] =3D v.raw[i + 0]; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Reverse4(D d, VFromD v) { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); i +=3D 4) { + ret.raw[i + 0] =3D v.raw[i + 3]; + ret.raw[i + 1] =3D v.raw[i + 2]; + ret.raw[i + 2] =3D v.raw[i + 1]; + ret.raw[i + 3] =3D v.raw[i + 0]; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD Reverse8(D d, VFromD v) { + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(d); i +=3D 8) { + ret.raw[i + 0] =3D v.raw[i + 7]; + ret.raw[i + 1] =3D v.raw[i + 6]; + ret.raw[i + 2] =3D v.raw[i + 5]; + ret.raw[i + 3] =3D v.raw[i + 4]; + ret.raw[i + 4] =3D v.raw[i + 3]; + ret.raw[i + 5] =3D v.raw[i + 2]; + ret.raw[i + 6] =3D v.raw[i + 1]; + ret.raw[i + 7] =3D v.raw[i + 0]; + } + return ret; +} + + + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle2301(Vec128 v) { + static_assert(sizeof(T) =3D=3D 4, "Only for 32-bit"); + static_assert(N =3D=3D 2 || N =3D=3D 4, "Does not make sense for N=3D1"); + return Reverse2(DFromV(), v); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle1032(Vec128 v) { + static_assert(sizeof(T) =3D=3D 4, "Only for 32-bit"); + Vec128 ret; + ret.raw[3] =3D v.raw[1]; + ret.raw[2] =3D v.raw[0]; + ret.raw[1] =3D v.raw[3]; + ret.raw[0] =3D v.raw[2]; + return ret; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle01(Vec128 v) { + static_assert(sizeof(T) =3D=3D 8, "Only for 64-bit"); + return Reverse2(DFromV(), v); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle0321(Vec128 v) { + Vec128 ret; + ret.raw[3] =3D v.raw[0]; + ret.raw[2] =3D v.raw[3]; + ret.raw[1] =3D v.raw[2]; + ret.raw[0] =3D v.raw[1]; + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle2103(Vec128 v) { + Vec128 ret; + ret.raw[3] =3D v.raw[2]; + ret.raw[2] =3D v.raw[1]; + ret.raw[1] =3D v.raw[0]; + ret.raw[0] =3D v.raw[3]; + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Shuffle0123(Vec128 v) { + return Reverse4(DFromV(), v); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Broadcast(Vec128 v) { + for (size_t i =3D 0; i < N; ++i) { + v.raw[i] =3D v.raw[kLane]; + } + return v; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 TableLookupBytes(Vec128 v, + Vec128 indices) { + const uint8_t* __restrict__ v_bytes =3D + reinterpret_cast(v.raw); + const uint8_t* __restrict__ idx_bytes =3D + reinterpret_cast(indices.raw); + Vec128 ret; + uint8_t* __restrict__ ret_bytes =3D + reinterpret_cast(ret.raw); + for (size_t i =3D 0; i < NI * sizeof(TI); ++i) { + const size_t idx =3D idx_bytes[i]; + + ret_bytes[i] =3D idx < sizeof(T) * N ? v_bytes[idx] : 0; + } + return ret; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 TableLookupBytesOr0(Vec128 v, + Vec128 indices) { + + return TableLookupBytes(v, indices); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 InterleaveLower(Vec128 a, Vec128 b) { + Vec128 ret; + for (size_t i =3D 0; i < N / 2; ++i) { + ret.raw[2 * i + 0] =3D a.raw[i]; + ret.raw[2 * i + 1] =3D b.raw[i]; + } + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V InterleaveLower(DFromV , V a, V b) { + return InterleaveLower(a, b); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD InterleaveUpper(D d, VFromD a, VFromD b= ) { + const Half dh; + VFromD ret; + for (size_t i =3D 0; i < MaxLanes(dh); ++i) { + ret.raw[2 * i + 0] =3D a.raw[MaxLanes(dh) + i]; + ret.raw[2 * i + 1] =3D b.raw[MaxLanes(dh) + i]; + } + return ret; +} + + + + + +template >> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ZipLower(V a, V b) { + return BitCast(DW(), InterleaveLower(a, b)); +} +template , class DW =3D RepartitionToWide> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ZipLower(DW dw, V a, V b) { + return BitCast(dw, InterleaveLower(D(), a, b)); +} + +template , class DW =3D RepartitionToWide> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ZipUpper(DW dw, V a, V b) { + return BitCast(dw, InterleaveUpper(D(), a, b)); +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) bool AllFalse(D d, MFromD mask) { + typename MFromD::Raw or_sum =3D 0; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + or_sum |=3D mask.bits[i]; + } + return or_sum =3D=3D 0; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) bool AllTrue(D d, MFromD mask) { + constexpr uint64_t kAll =3D LimitsMax::Raw>(); + uint64_t and_sum =3D kAll; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + and_sum &=3D mask.bits[i]; + } + return and_sum =3D=3D kAll; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) MFromD LoadMaskBits(D d, const uint8_t* __restrict__= bits) { + MFromD m; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + const size_t bit =3D size_t{1} << (i & 7); + const size_t idx_byte =3D i >> 3; + m.bits[i] =3D MFromD::FromBool((bits[idx_byte] & bit) !=3D 0); + } + return m; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t StoreMaskBits(D d, MFromD mask, uint8_t* bits= ) { + bits[0] =3D 0; + if (MaxLanes(d) > 8) bits[1] =3D 0; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + const size_t bit =3D size_t{1} << (i & 7); + const size_t idx_byte =3D i >> 3; + if (mask.bits[i]) { + bits[idx_byte] =3D static_cast(bits[idx_byte] | bit); + } + } + return MaxLanes(d) > 8 ? 2 : 1; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CountTrue(D d, MFromD mask) { + size_t count =3D 0; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + count +=3D mask.bits[i] !=3D 0; + } + return count; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t FindKnownFirstTrue(D d, MFromD mask) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + if (mask.bits[i] !=3D 0) return i; + } + do { } while (0); + return 0; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) intptr_t FindFirstTrue(D d, MFromD mask) { + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + if (mask.bits[i] !=3D 0) return static_cast(i); + } + return intptr_t{-1}; +} + + + +template +struct CompressIsPartition { + enum { value =3D (sizeof(T) !=3D 1) }; +}; + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Compress(Vec128 v, Mask128 mas= k) { + size_t count =3D 0; + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + if (mask.bits[i]) { + ret.raw[count++] =3D v.raw[i]; + } + } + for (size_t i =3D 0; i < N; ++i) { + if (!mask.bits[i]) { + ret.raw[count++] =3D v.raw[i]; + } + } + do { } while (0); + return ret; +} +# 2326 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/emu128-inl.h" +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 Expand(Vec128 v, const Mask128= mask) { + size_t in_pos =3D 0; + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + if (mask.bits[i]) { + ret.raw[i] =3D v.raw[in_pos++]; + } else { + ret.raw[i] =3D T(); + } + } + return ret; +} + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD LoadExpand(MFromD mask, D d, + const TFromD* __restrict__ unaligned) { + size_t in_pos =3D 0; + VFromD ret; + for (size_t i =3D 0; i < Lanes(d); ++i) { + if (mask.bits[i]) { + ret.raw[i] =3D unaligned[in_pos++]; + } else { + ret.raw[i] =3D TFromD(); + } + } + return ret; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 CompressNot(Vec128 v, Mask128 = mask) { + size_t count =3D 0; + Vec128 ret; + for (size_t i =3D 0; i < N; ++i) { + if (!mask.bits[i]) { + ret.raw[count++] =3D v.raw[i]; + } + } + for (size_t i =3D 0; i < N; ++i) { + if (mask.bits[i]) { + ret.raw[count++] =3D v.raw[i]; + } + } + do { } while (0); + return ret; +} + + +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 CompressBlocksNot(Vec128 v, + Mask128 ) { + return v; +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec128 CompressBits(Vec128 v, + const uint8_t* __restrict__ bits) { + return Compress(v, LoadMaskBits(Simd(), bits)); +} + + + + +template ) !=3D (1)>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressStore(VFromD v, MFromD mask, D d, + TFromD* __restrict__ unaligned) { + size_t count =3D 0; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + if (mask.bits[i]) { + unaligned[count++] =3D v.raw[i]; + } + } + return count; +} + + +template ) !=3D (1)>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressBlendedStore(VFromD v, MFromD mask= , D d, + TFromD* __restrict__ unaligned) { + return CompressStore(v, mask, d, unaligned); +} + + +template ) !=3D (1)>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressBitsStore(VFromD v, const uint8_t* __= restrict__ bits, + D d, TFromD* __restrict__ unaligned) { + const MFromD mask =3D LoadMaskBits(d, bits); + StoreU(Compress(v, mask), d, unaligned); + return CountTrue(d, mask); +} + + + +template , float>()>* =3D nullptr,= size_t N, class VBF16> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ReorderWidenMulAccumulate(D df32, VBF16 a, VB= F16 b, + const Vec128 sum0, + Vec128& sum1) { + const Rebind du32; + using VU32 =3D VFromD; + const VU32 odd =3D Set(du32, 0xFFFF0000u); + + const VU32 ae =3D ShiftLeft<16>(BitCast(du32, a)); + const VU32 ao =3D And(BitCast(du32, a), odd); + const VU32 be =3D ShiftLeft<16>(BitCast(du32, b)); + const VU32 bo =3D And(BitCast(du32, b), odd); + sum1 =3D MulAdd(BitCast(df32, ao), BitCast(df32, bo), sum1); + return MulAdd(BitCast(df32, ae), BitCast(df32, be), sum0); +} + +template , int32_t>()>* =3D nullpt= r, size_t N, class VI16> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD ReorderWidenMulAccumulate(D d32, VI16 a, VI16= b, + const Vec128 sum0, + Vec128& sum1) { + using VI32 =3D VFromD; + + const VI32 ae =3D ShiftRight<16>(ShiftLeft<16>(BitCast(d32, a))); + const VI32 be =3D ShiftRight<16>(ShiftLeft<16>(BitCast(d32, b))); + const VI32 ao =3D ShiftRight<16>(BitCast(d32, a)); + const VI32 bo =3D ShiftRight<16>(BitCast(d32, b)); + sum1 =3D Add(Mul(ao, bo), sum1); + return Add(Mul(ae, be), sum0); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VW RearrangeToOddPlusEven(VW sum0, VW sum1) { + return Add(sum0, sum1); +} + + + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD SumOfLanes(D d, VFromD v) { + T sum =3D T{0}; + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + sum +=3D v.raw[i]; + } + return Set(d, sum); +} +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD MinOfLanes(D d, VFromD v) { + T min =3D HighestValue(); + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + min =3D ((min) < (v.raw[i]) ? (min) : (v.raw[i])); + } + return Set(d, min); +} +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) VFromD MaxOfLanes(D d, VFromD v) { + T max =3D LowestValue(); + for (size_t i =3D 0; i < MaxLanes(d); ++i) { + max =3D ((max) > (v.raw[i]) ? (max) : (v.raw[i])); + } + return Set(d, max); +} + + + + + +inline __attribute__((always_inline)) Vec128 MulEven(Vec128 a, Vec128 b) { + alignas(16) uint64_t mul[2]; + mul[0] =3D Mul128(GetLane(a), GetLane(b), &mul[1]); + return Load(Full128(), mul); +} + +inline __attribute__((always_inline)) Vec128 MulOdd(Vec128 a, Vec128 b) { + alignas(16) uint64_t mul[2]; + const Half> d2; + mul[0] =3D + Mul128(GetLane(UpperHalf(d2, a)), GetLane(UpperHalf(d2, b)), &mul[1]= ); + return Load(Full128(), mul); +} + + +} +} +static_assert(true, "For requiring trailing semicolon"); +# 413 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" 2 + + + + + + +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-inl= .h" 1 +# 27 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-in= l.h" +static_assert(true, "For requiring trailing semicolon"); +namespace hwy { +namespace N_EMU128 { + + +template +using LaneType =3D decltype(GetLane(V())); + + + + + +template +using Vec =3D decltype(Zero(D())); + + + + +template +using Mask =3D decltype(MaskFromVec(Zero(D()))); + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Clamp(const V v, const V lo, const V hi) { + return Min(Max(lo, v), hi); +} + + + + + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V CombineShiftRightLanes(D d, const V hi, const V lo) { + constexpr size_t kBytes =3D kLanes * sizeof(LaneType); + static_assert(kBytes < 16, "Shift count is per-block"); + return CombineShiftRightBytes(d, hi, lo); +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec SignBit(D d) { + const RebindToUnsigned du; + return BitCast(d, Set(du, SignMask>())); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec NaN(D d) { + const RebindToSigned di; + + + return BitCast(d, Set(di, LimitsMax>())); +} + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec Inf(D d) { + const RebindToUnsigned du; + using T =3D TFromD; + using TU =3D TFromD; + const TU max_x2 =3D static_cast(MaxExponentTimes2()); + return BitCast(d, Set(du, max_x2 >> 1)); +} + + + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void SafeFillN(const size_t num, const T value, D d, + T* __restrict__ to) { + + (void)d; + for (size_t i =3D 0; i < num; ++i) { + to[i] =3D value; + } + + + +} + + + +template > +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) void SafeCopyN(const size_t num, D d, const T* __restri= ct__ from, + T* __restrict__ to) { + + (void)d; + for (size_t i =3D 0; i < num; ++i) { + to[i] =3D from[i]; + } + + + + +} +# 983 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-i= nl.h" +template >() && !hwy::IsSp= ecialFloat >()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V AbsDiff(V a, V b) { + return Sub(Max(a, b), Min(a, b)); +} +# 997 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-i= nl.h" +template >, uint8_t>()>* = =3D nullptr, + hwy::EnableIf<(DFromV::kPrivateLanes * sizeof(TFromD >) > ((1LL << 61) =3D=3D (1LL << 62) ? 0 : 4))>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) Vec>> SumsOf8AbsDiff(V = a, V b) { + return SumsOf8(AbsDiff(a, b)); +} +# 1011 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +namespace detail { +# 1021 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +template +inline __attribute__((always_inline)) V SubBytes(V state) { + const DFromV du; + const auto mask =3D Set(du, uint8_t{0xF}); + + + { + alignas(16) static constexpr uint8_t basisL[16] =3D { + 0x00, 0x70, 0x2A, 0x5A, 0x98, 0xE8, 0xB2, 0xC2, + 0x08, 0x78, 0x22, 0x52, 0x90, 0xE0, 0xBA, 0xCA}; + alignas(16) static constexpr uint8_t basisU[16] =3D { + 0x00, 0x4D, 0x7C, 0x31, 0x7D, 0x30, 0x01, 0x4C, + 0x81, 0xCC, 0xFD, 0xB0, 0xFC, 0xB1, 0x80, 0xCD}; + const auto sL =3D And(state, mask); + const auto sU =3D ShiftRight<4>(state); + const auto gf4L =3D TableLookupBytes(LoadDup128(du, basisL), sL); + const auto gf4U =3D TableLookupBytes(LoadDup128(du, basisU), sU); + state =3D Xor(gf4L, gf4U); + } + + + + alignas(16) static constexpr uint8_t kZetaInv[16] =3D { + 0x80, 7, 11, 15, 6, 10, 4, 1, 9, 8, 5, 2, 12, 14, 13, 3}; + alignas(16) static constexpr uint8_t kInv[16] =3D { + 0x80, 1, 8, 13, 15, 6, 5, 14, 2, 12, 11, 10, 9, 3, 7, 4}; + const auto tbl =3D LoadDup128(du, kInv); + const auto sL =3D And(state, mask); + const auto sU =3D ShiftRight<4>(state); + const auto sX =3D Xor(sU, sL); + const auto invL =3D TableLookupBytes(LoadDup128(du, kZetaInv), sL); + const auto invU =3D TableLookupBytes(tbl, sU); + const auto invX =3D TableLookupBytes(tbl, sX); + const auto outL =3D Xor(sX, TableLookupBytesOr0(tbl, Xor(invL, invU))); + const auto outU =3D Xor(sU, TableLookupBytesOr0(tbl, Xor(invL, invX))); + + + + alignas(16) static constexpr uint8_t kAffineL[16] =3D { + 0x00, 0xC7, 0xBD, 0x6F, 0x17, 0x6D, 0xD2, 0xD0, + 0x78, 0xA8, 0x02, 0xC5, 0x7A, 0xBF, 0xAA, 0x15}; + alignas(16) static constexpr uint8_t kAffineU[16] =3D { + 0x00, 0x6A, 0xBB, 0x5F, 0xA5, 0x74, 0xE4, 0xCF, + 0xFA, 0x35, 0x2B, 0x41, 0xD1, 0x90, 0x1E, 0x8E}; + const auto affL =3D TableLookupBytesOr0(LoadDup128(du, kAffineL), outL); + const auto affU =3D TableLookupBytesOr0(LoadDup128(du, kAffineU), outU); + return Xor(Xor(affL, affU), Set(du, uint8_t{0x63})); +} + +} +# 1085 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +namespace detail { + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V ShiftRows(const V state) { + const DFromV du; + alignas(16) static constexpr uint8_t kShiftRow[16] =3D { + 0, 5, 10, 15, + 4, 9, 14, 3, + 8, 13, 2, 7, + 12, 1, 6, 11}; + const auto shift_row =3D LoadDup128(du, kShiftRow); + return TableLookupBytes(state, shift_row); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V MixColumns(const V state) { + const DFromV du; + + + + + + alignas(16) static constexpr uint8_t k2301[16] =3D { + 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13}; + alignas(16) static constexpr uint8_t k1230[16] =3D { + 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12}; + const RebindToSigned di; + const auto msb =3D Lt(BitCast(di, state), Zero(di)); + const auto overflow =3D BitCast(du, IfThenElseZero(msb, Set(di, int8_t{0= x1B}))); + const auto d =3D Xor(Add(state, state), overflow); + const auto s2301 =3D TableLookupBytes(state, LoadDup128(du, k2301)); + const auto d_s2301 =3D Xor(d, s2301); + const auto t_s2301 =3D Xor(state, d_s2301); + const auto t1230_s3012 =3D TableLookupBytes(t_s2301, LoadDup128(du, k123= 0)); + return Xor(d_s2301, t1230_s3012); +} + +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V AESRound(V state, const V round_key) { + + + state =3D detail::SubBytes(state); + state =3D detail::ShiftRows(state); + state =3D detail::MixColumns(state); + state =3D Xor(state, round_key); + return state; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V AESLastRound(V state, const V round_key) { + + state =3D detail::SubBytes(state); + state =3D detail::ShiftRows(state); + state =3D Xor(state, round_key); + return state; +} + + + + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V CLMulLower(V a, V b) { + const DFromV d; + static_assert(IsSame, uint64_t>(), "V must be u64"); + const auto k1 =3D Set(d, 0x1111111111111111ULL); + const auto k2 =3D Set(d, 0x2222222222222222ULL); + const auto k4 =3D Set(d, 0x4444444444444444ULL); + const auto k8 =3D Set(d, 0x8888888888888888ULL); + const auto a0 =3D And(a, k1); + const auto a1 =3D And(a, k2); + const auto a2 =3D And(a, k4); + const auto a3 =3D And(a, k8); + const auto b0 =3D And(b, k1); + const auto b1 =3D And(b, k2); + const auto b2 =3D And(b, k4); + const auto b3 =3D And(b, k8); + + auto m0 =3D Xor(MulEven(a0, b0), MulEven(a1, b3)); + auto m1 =3D Xor(MulEven(a0, b1), MulEven(a1, b0)); + auto m2 =3D Xor(MulEven(a0, b2), MulEven(a1, b1)); + auto m3 =3D Xor(MulEven(a0, b3), MulEven(a1, b2)); + m0 =3D Xor(m0, Xor(MulEven(a2, b2), MulEven(a3, b1))); + m1 =3D Xor(m1, Xor(MulEven(a2, b3), MulEven(a3, b2))); + m2 =3D Xor(m2, Xor(MulEven(a2, b0), MulEven(a3, b3))); + m3 =3D Xor(m3, Xor(MulEven(a2, b1), MulEven(a3, b0))); + return Or(Or(And(m0, k1), And(m1, k2)), Or(And(m2, k4), And(m3, k8))); +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V CLMulUpper(V a, V b) { + const DFromV d; + static_assert(IsSame, uint64_t>(), "V must be u64"); + const auto k1 =3D Set(d, 0x1111111111111111ULL); + const auto k2 =3D Set(d, 0x2222222222222222ULL); + const auto k4 =3D Set(d, 0x4444444444444444ULL); + const auto k8 =3D Set(d, 0x8888888888888888ULL); + const auto a0 =3D And(a, k1); + const auto a1 =3D And(a, k2); + const auto a2 =3D And(a, k4); + const auto a3 =3D And(a, k8); + const auto b0 =3D And(b, k1); + const auto b1 =3D And(b, k2); + const auto b2 =3D And(b, k4); + const auto b3 =3D And(b, k8); + + auto m0 =3D Xor(MulOdd(a0, b0), MulOdd(a1, b3)); + auto m1 =3D Xor(MulOdd(a0, b1), MulOdd(a1, b0)); + auto m2 =3D Xor(MulOdd(a0, b2), MulOdd(a1, b1)); + auto m3 =3D Xor(MulOdd(a0, b3), MulOdd(a1, b2)); + m0 =3D Xor(m0, Xor(MulOdd(a2, b2), MulOdd(a3, b1))); + m1 =3D Xor(m1, Xor(MulOdd(a2, b3), MulOdd(a3, b2))); + m2 =3D Xor(m2, Xor(MulOdd(a2, b0), MulOdd(a3, b3))); + m3 =3D Xor(m3, Xor(MulOdd(a2, b1), MulOdd(a3, b0))); + return Or(Or(And(m0, k1), And(m1, k2)), Or(And(m2, k4), And(m3, k8))); +} +# 1226 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +template , hwy::EnableIf, = uint8_t>()>* =3D nullptr, + hwy::EnableIf<(D::kPrivateLanes * sizeof(TFromD) > 8)>* =3D n= ullptr, void* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V PopulationCount(V v) { + const D d; + alignas(16) constexpr uint8_t kLookup[16] =3D { + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, + }; + const auto lo =3D And(v, Set(d, uint8_t{0xF})); + const auto hi =3D ShiftRight<4>(v); + const auto lookup =3D LoadDup128(d, kLookup); + return Add(TableLookupBytes(lookup, hi), TableLookupBytes(lookup, lo)); +} + + + + +template , hwy::EnableIf, = uint8_t>()>* =3D nullptr, + hwy::EnableIf) <=3D 8>* =3D = nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V PopulationCount(V v) { + const D d; + + const V k33 =3D Set(d, uint8_t{0x33}); + v =3D Sub(v, And(ShiftRight<1>(v), Set(d, uint8_t{0x55}))); + v =3D Add(And(ShiftRight<2>(v), k33), And(v, k33)); + return And(Add(v, ShiftRight<4>(v)), Set(d, uint8_t{0x0F})); +} + + +template , hwy::EnableIf, = uint16_t>()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V PopulationCount(V v) { + const D d; + const Repartition d8; + const auto vals =3D BitCast(d, PopulationCount(BitCast(d8, v))); + return Add(ShiftRight<8>(vals), And(vals, Set(d, uint16_t{0xFF}))); +} + +template , hwy::EnableIf, = uint32_t>()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V PopulationCount(V v) { + const D d; + Repartition d16; + auto vals =3D BitCast(d, PopulationCount(BitCast(d16, v))); + return Add(ShiftRight<16>(vals), And(vals, Set(d, uint32_t{0xFF}))); +} + + +template , hwy::EnableIf, = uint64_t>()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V PopulationCount(V v) { + const D d; + Repartition d32; + auto vals =3D BitCast(d, PopulationCount(BitCast(d32, v))); + return Add(ShiftRight<32>(vals), And(vals, Set(d, 0xFFULL))); +} + + + + + +template ::kPrivateLanes * sizeof(TFromV<= V>) =3D=3D 8>* =3D nullptr, hwy::EnableIf >, double= >()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V operator*(V x, V y) { + return Set(DFromV(), GetLane(x) * GetLane(y)); +} + + +template ) =3D=3D (8)>* =3D nullpt= r, hwy::EnableIf::kPrivateLanes * sizeof(TFromV) =3D=3D 8>* = =3D nullptr, + hwy::EnableIf >()>* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V operator*(V x, V y) { + const DFromV d; + using T =3D TFromD; + using TU =3D MakeUnsigned; + const TU xu =3D static_cast(GetLane(x)); + const TU yu =3D static_cast(GetLane(y)); + return Set(d, static_cast(xu * yu)); +} +# 1308 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +template , hwy::EnableIf, uint64_t>()>* =3D nullptr, + hwy::EnableIf<(D64::kPrivateLanes * sizeof(TFromD) > 8)>* = =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V operator*(V x, V y) { + RepartitionToNarrow d32; + auto x32 =3D BitCast(d32, x); + auto y32 =3D BitCast(d32, y); + auto lolo =3D BitCast(d32, MulEven(x32, y32)); + auto lohi =3D BitCast(d32, MulEven(x32, BitCast(d32, ShiftRight<32>(y)))= ); + auto hilo =3D BitCast(d32, MulEven(BitCast(d32, ShiftRight<32>(x)), y32)= ); + auto hi =3D BitCast(d32, ShiftLeft<32>(BitCast(D64{}, lohi + hilo))); + return BitCast(D64{}, lolo + hi); +} +template , hwy::EnableIf, int64_t>()>* =3D nullptr, + hwy::EnableIf<(DI64::kPrivateLanes * sizeof(TFromD) > 8)>*= =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V operator*(V x, V y) { + RebindToUnsigned du64; + return BitCast(DI64{}, BitCast(du64, x) * BitCast(du64, y)); +} +# 1337 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +template * =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressBitsStore(V v, const uint8_t* __restrict= __ bits, D d, + T* unaligned) { + alignas(16) T lanes[MaxLanes(d)]; + Store(v, d, lanes); + + const Simd d8; + T* __restrict__ pos =3D unaligned; + + alignas(16) constexpr T table[2048] =3D { + 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 1, 0, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 2, 0, 1, 3, 4, 5, 6, 7, 0, 2, 1, 3, 4, 5, 6, 7, + 1, 2, 0, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 3, 0, 1, 2, 4, 5, 6, 7, 0, 3, 1, 2, 4, 5, 6, 7, + 1, 3, 0, 2, 4, 5, 6, 7, 0, 1, 3, 2, 4, 5, 6, 7, + 2, 3, 0, 1, 4, 5, 6, 7, 0, 2, 3, 1, 4, 5, 6, 7, + 1, 2, 3, 0, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 4, 0, 1, 2, 3, 5, 6, 7, 0, 4, 1, 2, 3, 5, 6, 7, + 1, 4, 0, 2, 3, 5, 6, 7, 0, 1, 4, 2, 3, 5, 6, 7, + 2, 4, 0, 1, 3, 5, 6, 7, 0, 2, 4, 1, 3, 5, 6, 7, + 1, 2, 4, 0, 3, 5, 6, 7, 0, 1, 2, 4, 3, 5, 6, 7, + 3, 4, 0, 1, 2, 5, 6, 7, 0, 3, 4, 1, 2, 5, 6, 7, + 1, 3, 4, 0, 2, 5, 6, 7, 0, 1, 3, 4, 2, 5, 6, 7, + 2, 3, 4, 0, 1, 5, 6, 7, 0, 2, 3, 4, 1, 5, 6, 7, + 1, 2, 3, 4, 0, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 5, 0, 1, 2, 3, 4, 6, 7, 0, 5, 1, 2, 3, 4, 6, 7, + 1, 5, 0, 2, 3, 4, 6, 7, 0, 1, 5, 2, 3, 4, 6, 7, + 2, 5, 0, 1, 3, 4, 6, 7, 0, 2, 5, 1, 3, 4, 6, 7, + 1, 2, 5, 0, 3, 4, 6, 7, 0, 1, 2, 5, 3, 4, 6, 7, + 3, 5, 0, 1, 2, 4, 6, 7, 0, 3, 5, 1, 2, 4, 6, 7, + 1, 3, 5, 0, 2, 4, 6, 7, 0, 1, 3, 5, 2, 4, 6, 7, + 2, 3, 5, 0, 1, 4, 6, 7, 0, 2, 3, 5, 1, 4, 6, 7, + 1, 2, 3, 5, 0, 4, 6, 7, 0, 1, 2, 3, 5, 4, 6, 7, + 4, 5, 0, 1, 2, 3, 6, 7, 0, 4, 5, 1, 2, 3, 6, 7, + 1, 4, 5, 0, 2, 3, 6, 7, 0, 1, 4, 5, 2, 3, 6, 7, + 2, 4, 5, 0, 1, 3, 6, 7, 0, 2, 4, 5, 1, 3, 6, 7, + 1, 2, 4, 5, 0, 3, 6, 7, 0, 1, 2, 4, 5, 3, 6, 7, + 3, 4, 5, 0, 1, 2, 6, 7, 0, 3, 4, 5, 1, 2, 6, 7, + 1, 3, 4, 5, 0, 2, 6, 7, 0, 1, 3, 4, 5, 2, 6, 7, + 2, 3, 4, 5, 0, 1, 6, 7, 0, 2, 3, 4, 5, 1, 6, 7, + 1, 2, 3, 4, 5, 0, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 6, 0, 1, 2, 3, 4, 5, 7, 0, 6, 1, 2, 3, 4, 5, 7, + 1, 6, 0, 2, 3, 4, 5, 7, 0, 1, 6, 2, 3, 4, 5, 7, + 2, 6, 0, 1, 3, 4, 5, 7, 0, 2, 6, 1, 3, 4, 5, 7, + 1, 2, 6, 0, 3, 4, 5, 7, 0, 1, 2, 6, 3, 4, 5, 7, + 3, 6, 0, 1, 2, 4, 5, 7, 0, 3, 6, 1, 2, 4, 5, 7, + 1, 3, 6, 0, 2, 4, 5, 7, 0, 1, 3, 6, 2, 4, 5, 7, + 2, 3, 6, 0, 1, 4, 5, 7, 0, 2, 3, 6, 1, 4, 5, 7, + 1, 2, 3, 6, 0, 4, 5, 7, 0, 1, 2, 3, 6, 4, 5, 7, + 4, 6, 0, 1, 2, 3, 5, 7, 0, 4, 6, 1, 2, 3, 5, 7, + 1, 4, 6, 0, 2, 3, 5, 7, 0, 1, 4, 6, 2, 3, 5, 7, + 2, 4, 6, 0, 1, 3, 5, 7, 0, 2, 4, 6, 1, 3, 5, 7, + 1, 2, 4, 6, 0, 3, 5, 7, 0, 1, 2, 4, 6, 3, 5, 7, + 3, 4, 6, 0, 1, 2, 5, 7, 0, 3, 4, 6, 1, 2, 5, 7, + 1, 3, 4, 6, 0, 2, 5, 7, 0, 1, 3, 4, 6, 2, 5, 7, + 2, 3, 4, 6, 0, 1, 5, 7, 0, 2, 3, 4, 6, 1, 5, 7, + 1, 2, 3, 4, 6, 0, 5, 7, 0, 1, 2, 3, 4, 6, 5, 7, + 5, 6, 0, 1, 2, 3, 4, 7, 0, 5, 6, 1, 2, 3, 4, 7, + 1, 5, 6, 0, 2, 3, 4, 7, 0, 1, 5, 6, 2, 3, 4, 7, + 2, 5, 6, 0, 1, 3, 4, 7, 0, 2, 5, 6, 1, 3, 4, 7, + 1, 2, 5, 6, 0, 3, 4, 7, 0, 1, 2, 5, 6, 3, 4, 7, + 3, 5, 6, 0, 1, 2, 4, 7, 0, 3, 5, 6, 1, 2, 4, 7, + 1, 3, 5, 6, 0, 2, 4, 7, 0, 1, 3, 5, 6, 2, 4, 7, + 2, 3, 5, 6, 0, 1, 4, 7, 0, 2, 3, 5, 6, 1, 4, 7, + 1, 2, 3, 5, 6, 0, 4, 7, 0, 1, 2, 3, 5, 6, 4, 7, + 4, 5, 6, 0, 1, 2, 3, 7, 0, 4, 5, 6, 1, 2, 3, 7, + 1, 4, 5, 6, 0, 2, 3, 7, 0, 1, 4, 5, 6, 2, 3, 7, + 2, 4, 5, 6, 0, 1, 3, 7, 0, 2, 4, 5, 6, 1, 3, 7, + 1, 2, 4, 5, 6, 0, 3, 7, 0, 1, 2, 4, 5, 6, 3, 7, + 3, 4, 5, 6, 0, 1, 2, 7, 0, 3, 4, 5, 6, 1, 2, 7, + 1, 3, 4, 5, 6, 0, 2, 7, 0, 1, 3, 4, 5, 6, 2, 7, + 2, 3, 4, 5, 6, 0, 1, 7, 0, 2, 3, 4, 5, 6, 1, 7, + 1, 2, 3, 4, 5, 6, 0, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 7, 0, 1, 2, 3, 4, 5, 6, 0, 7, 1, 2, 3, 4, 5, 6, + 1, 7, 0, 2, 3, 4, 5, 6, 0, 1, 7, 2, 3, 4, 5, 6, + 2, 7, 0, 1, 3, 4, 5, 6, 0, 2, 7, 1, 3, 4, 5, 6, + 1, 2, 7, 0, 3, 4, 5, 6, 0, 1, 2, 7, 3, 4, 5, 6, + 3, 7, 0, 1, 2, 4, 5, 6, 0, 3, 7, 1, 2, 4, 5, 6, + 1, 3, 7, 0, 2, 4, 5, 6, 0, 1, 3, 7, 2, 4, 5, 6, + 2, 3, 7, 0, 1, 4, 5, 6, 0, 2, 3, 7, 1, 4, 5, 6, + 1, 2, 3, 7, 0, 4, 5, 6, 0, 1, 2, 3, 7, 4, 5, 6, + 4, 7, 0, 1, 2, 3, 5, 6, 0, 4, 7, 1, 2, 3, 5, 6, + 1, 4, 7, 0, 2, 3, 5, 6, 0, 1, 4, 7, 2, 3, 5, 6, + 2, 4, 7, 0, 1, 3, 5, 6, 0, 2, 4, 7, 1, 3, 5, 6, + 1, 2, 4, 7, 0, 3, 5, 6, 0, 1, 2, 4, 7, 3, 5, 6, + 3, 4, 7, 0, 1, 2, 5, 6, 0, 3, 4, 7, 1, 2, 5, 6, + 1, 3, 4, 7, 0, 2, 5, 6, 0, 1, 3, 4, 7, 2, 5, 6, + 2, 3, 4, 7, 0, 1, 5, 6, 0, 2, 3, 4, 7, 1, 5, 6, + 1, 2, 3, 4, 7, 0, 5, 6, 0, 1, 2, 3, 4, 7, 5, 6, + 5, 7, 0, 1, 2, 3, 4, 6, 0, 5, 7, 1, 2, 3, 4, 6, + 1, 5, 7, 0, 2, 3, 4, 6, 0, 1, 5, 7, 2, 3, 4, 6, + 2, 5, 7, 0, 1, 3, 4, 6, 0, 2, 5, 7, 1, 3, 4, 6, + 1, 2, 5, 7, 0, 3, 4, 6, 0, 1, 2, 5, 7, 3, 4, 6, + 3, 5, 7, 0, 1, 2, 4, 6, 0, 3, 5, 7, 1, 2, 4, 6, + 1, 3, 5, 7, 0, 2, 4, 6, 0, 1, 3, 5, 7, 2, 4, 6, + 2, 3, 5, 7, 0, 1, 4, 6, 0, 2, 3, 5, 7, 1, 4, 6, + 1, 2, 3, 5, 7, 0, 4, 6, 0, 1, 2, 3, 5, 7, 4, 6, + 4, 5, 7, 0, 1, 2, 3, 6, 0, 4, 5, 7, 1, 2, 3, 6, + 1, 4, 5, 7, 0, 2, 3, 6, 0, 1, 4, 5, 7, 2, 3, 6, + 2, 4, 5, 7, 0, 1, 3, 6, 0, 2, 4, 5, 7, 1, 3, 6, + 1, 2, 4, 5, 7, 0, 3, 6, 0, 1, 2, 4, 5, 7, 3, 6, + 3, 4, 5, 7, 0, 1, 2, 6, 0, 3, 4, 5, 7, 1, 2, 6, + 1, 3, 4, 5, 7, 0, 2, 6, 0, 1, 3, 4, 5, 7, 2, 6, + 2, 3, 4, 5, 7, 0, 1, 6, 0, 2, 3, 4, 5, 7, 1, 6, + 1, 2, 3, 4, 5, 7, 0, 6, 0, 1, 2, 3, 4, 5, 7, 6, + 6, 7, 0, 1, 2, 3, 4, 5, 0, 6, 7, 1, 2, 3, 4, 5, + 1, 6, 7, 0, 2, 3, 4, 5, 0, 1, 6, 7, 2, 3, 4, 5, + 2, 6, 7, 0, 1, 3, 4, 5, 0, 2, 6, 7, 1, 3, 4, 5, + 1, 2, 6, 7, 0, 3, 4, 5, 0, 1, 2, 6, 7, 3, 4, 5, + 3, 6, 7, 0, 1, 2, 4, 5, 0, 3, 6, 7, 1, 2, 4, 5, + 1, 3, 6, 7, 0, 2, 4, 5, 0, 1, 3, 6, 7, 2, 4, 5, + 2, 3, 6, 7, 0, 1, 4, 5, 0, 2, 3, 6, 7, 1, 4, 5, + 1, 2, 3, 6, 7, 0, 4, 5, 0, 1, 2, 3, 6, 7, 4, 5, + 4, 6, 7, 0, 1, 2, 3, 5, 0, 4, 6, 7, 1, 2, 3, 5, + 1, 4, 6, 7, 0, 2, 3, 5, 0, 1, 4, 6, 7, 2, 3, 5, + 2, 4, 6, 7, 0, 1, 3, 5, 0, 2, 4, 6, 7, 1, 3, 5, + 1, 2, 4, 6, 7, 0, 3, 5, 0, 1, 2, 4, 6, 7, 3, 5, + 3, 4, 6, 7, 0, 1, 2, 5, 0, 3, 4, 6, 7, 1, 2, 5, + 1, 3, 4, 6, 7, 0, 2, 5, 0, 1, 3, 4, 6, 7, 2, 5, + 2, 3, 4, 6, 7, 0, 1, 5, 0, 2, 3, 4, 6, 7, 1, 5, + 1, 2, 3, 4, 6, 7, 0, 5, 0, 1, 2, 3, 4, 6, 7, 5, + 5, 6, 7, 0, 1, 2, 3, 4, 0, 5, 6, 7, 1, 2, 3, 4, + 1, 5, 6, 7, 0, 2, 3, 4, 0, 1, 5, 6, 7, 2, 3, 4, + 2, 5, 6, 7, 0, 1, 3, 4, 0, 2, 5, 6, 7, 1, 3, 4, + 1, 2, 5, 6, 7, 0, 3, 4, 0, 1, 2, 5, 6, 7, 3, 4, + 3, 5, 6, 7, 0, 1, 2, 4, 0, 3, 5, 6, 7, 1, 2, 4, + 1, 3, 5, 6, 7, 0, 2, 4, 0, 1, 3, 5, 6, 7, 2, 4, + 2, 3, 5, 6, 7, 0, 1, 4, 0, 2, 3, 5, 6, 7, 1, 4, + 1, 2, 3, 5, 6, 7, 0, 4, 0, 1, 2, 3, 5, 6, 7, 4, + 4, 5, 6, 7, 0, 1, 2, 3, 0, 4, 5, 6, 7, 1, 2, 3, + 1, 4, 5, 6, 7, 0, 2, 3, 0, 1, 4, 5, 6, 7, 2, 3, + 2, 4, 5, 6, 7, 0, 1, 3, 0, 2, 4, 5, 6, 7, 1, 3, + 1, 2, 4, 5, 6, 7, 0, 3, 0, 1, 2, 4, 5, 6, 7, 3, + 3, 4, 5, 6, 7, 0, 1, 2, 0, 3, 4, 5, 6, 7, 1, 2, + 1, 3, 4, 5, 6, 7, 0, 2, 0, 1, 3, 4, 5, 6, 7, 2, + 2, 3, 4, 5, 6, 7, 0, 1, 0, 2, 3, 4, 5, 6, 7, 1, + 1, 2, 3, 4, 5, 6, 7, 0, 0, 1, 2, 3, 4, 5, 6, 7}; + + for (size_t i =3D 0; i < Lanes(d); i +=3D 8) { + + + const size_t bits8 =3D bits[i / 8]; + const auto indices =3D Load(d8, table + bits8 * 8); + const auto compressed =3D TableLookupBytes(LoadU(d8, lanes + i), indic= es); + StoreU(compressed, d8, pos); + pos +=3D PopCount(bits8); + } + return static_cast(pos - unaligned); +} + +template * =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressStore(V v, M mask, D d, T* __restrict__ = unaligned) { + uint8_t bits[((size_t{8}) > (MaxLanes(d) / 8) ? (size_t{8}) : (MaxLanes(= d) / 8))]; + (void)StoreMaskBits(d, mask, bits); + return CompressBitsStore(v, bits, d, unaligned); +} + +template * =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) size_t CompressBlendedStore(V v, M mask, D d, + T* __restrict__ unaligned) { + alignas(16) T buf[MaxLanes(d)]; + const size_t bytes =3D CompressStore(v, mask, d, buf); + BlendedStore(Load(d, buf), FirstN(d, bytes), d, unaligned); + return bytes; +} + + +template , hwy::EnableIf* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Compress(V v, const M mask) { + const DFromV d; + alignas(16) T lanes[MaxLanes(d)]; + (void)CompressStore(v, mask, d, lanes); + return Load(d, lanes); +} + +template , hwy::EnableIf* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V CompressBits(V v, const uint8_t* __restrict__ bits) { + const DFromV d; + alignas(16) T lanes[MaxLanes(d)]; + (void)CompressBitsStore(v, bits, d, lanes); + return Load(d, lanes); +} + +template , hwy::EnableIf* =3D nullptr> +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V CompressNot(V v, M mask) { + return Compress(v, Not(mask)); +} +# 2189 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/ops/generic_ops-= inl.h" +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Add(V a, V b) { + return a + b; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Sub(V a, V b) { + return a - b; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Mul(V a, V b) { + return a * b; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) V Div(V a, V b) { + return a / b; +} + +template +V Shl(V a, V b) { + return a << b; +} +template +V Shr(V a, V b) { + return a >> b; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Eq(V a, V b) -> decltype(a =3D=3D b) { + return a =3D=3D b; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Ne(V a, V b) -> decltype(a =3D=3D b) { + return a !=3D b; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Lt(V a, V b) -> decltype(a =3D=3D b) { + return a < b; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Gt(V a, V b) -> decltype(a =3D=3D b) { + return a > b; +} +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Ge(V a, V b) -> decltype(a =3D=3D b) { + return a >=3D b; +} + +template +static inline __attribute__((always_inline)) __attribute__((flatten)) __at= tribute__((unused)) auto Le(V a, V b) -> decltype(a =3D=3D b) { + return a <=3D b; +} + + + + +} +} +static_assert(true, "For requiring trailing semicolon"); +# 420 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/highway.h" 2 +# 26 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form-inl.h" 2 + +static_assert(true, "For requiring trailing semicolon"); +namespace hwy { +namespace N_EMU128 { +# 51 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form-inl.h" +template > +void Generate(D d, T* __restrict__ out, size_t count, const Func& func) { + const RebindToUnsigned du; + using TU =3D TFromD; + const size_t N =3D Lanes(d); + + size_t idx =3D 0; + Vec vidx =3D Iota(du, 0); + for (; idx + N <=3D count; idx +=3D N) { + StoreU(func(d, vidx), d, out + idx); + vidx =3D Add(vidx, Set(du, static_cast(N))); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + const RebindToUnsigned du1; + for (; idx < count; ++idx) { + StoreU(func(d1, Set(du1, static_cast(idx))), d1, out + idx); + } + + + + + + +} + + + +template > +void Transform(D d, T* __restrict__ inout, size_t count, const Func& func)= { + const size_t N =3D Lanes(d); + + size_t idx =3D 0; + for (; idx + N <=3D count; idx +=3D N) { + const Vec v =3D LoadU(d, inout + idx); + StoreU(func(d, v), d, inout + idx); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + for (; idx < count; ++idx) { + using V1 =3D Vec; + const V1 v =3D LoadU(d1, inout + idx); + StoreU(func(d1, v), d1, inout + idx); + } + + + + + + + +} + + + +template > +void Transform1(D d, T* __restrict__ inout, size_t count, + const T* __restrict__ in1, const Func& func) { + const size_t N =3D Lanes(d); + + size_t idx =3D 0; + for (; idx + N <=3D count; idx +=3D N) { + const Vec v =3D LoadU(d, inout + idx); + const Vec v1 =3D LoadU(d, in1 + idx); + StoreU(func(d, v, v1), d, inout + idx); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + for (; idx < count; ++idx) { + using V1 =3D Vec; + const V1 v =3D LoadU(d1, inout + idx); + const V1 v1 =3D LoadU(d1, in1 + idx); + StoreU(func(d1, v, v1), d1, inout + idx); + } +# 148 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/tran= sform-inl.h" +} + + + +template > +void Transform2(D d, T* __restrict__ inout, size_t count, + const T* __restrict__ in1, const T* __restrict__ in2, + const Func& func) { + const size_t N =3D Lanes(d); + + size_t idx =3D 0; + for (; idx + N <=3D count; idx +=3D N) { + const Vec v =3D LoadU(d, inout + idx); + const Vec v1 =3D LoadU(d, in1 + idx); + const Vec v2 =3D LoadU(d, in2 + idx); + StoreU(func(d, v, v1, v2), d, inout + idx); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + for (; idx < count; ++idx) { + using V1 =3D Vec; + const V1 v =3D LoadU(d1, inout + idx); + const V1 v1 =3D LoadU(d1, in1 + idx); + const V1 v2 =3D LoadU(d1, in2 + idx); + StoreU(func(d1, v, v1, v2), d1, inout + idx); + } +# 188 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/tran= sform-inl.h" +} + +template > +void Replace(D d, T* __restrict__ inout, size_t count, T new_t, T old_t) { + const size_t N =3D Lanes(d); + const Vec old_v =3D Set(d, old_t); + const Vec new_v =3D Set(d, new_t); + + size_t idx =3D 0; + for (; idx + N <=3D count; idx +=3D N) { + Vec v =3D LoadU(d, inout + idx); + StoreU(IfThenElse(Eq(v, old_v), new_v, v), d, inout + idx); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + const Vec old_v1 =3D Set(d1, old_t); + const Vec new_v1 =3D Set(d1, new_t); + for (; idx < count; ++idx) { + using V1 =3D Vec; + const V1 v1 =3D LoadU(d1, inout + idx); + StoreU(IfThenElse(Eq(v1, old_v1), new_v1, v1), d1, inout + idx); + } + + + + + + + +} + +template > +void ReplaceIf(D d, T* __restrict__ inout, size_t count, T new_t, + const Func& func) { + const size_t N =3D Lanes(d); + const Vec new_v =3D Set(d, new_t); + + size_t idx =3D 0; + for (; idx + N <=3D count; idx +=3D N) { + Vec v =3D LoadU(d, inout + idx); + StoreU(IfThenElse(func(d, v), new_v, v), d, inout + idx); + } + + + if (__builtin_expect(!!(idx =3D=3D count), 0)) return; + + + + const CappedTag d1; + const Vec new_v1 =3D Set(d1, new_t); + for (; idx < count; ++idx) { + using V1 =3D Vec; + const V1 v =3D LoadU(d1, inout + idx); + StoreU(IfThenElse(func(d1, v), new_v1, v), d1, inout + idx); + } + + + + + + + +} + + +} +} +static_assert(true, "For requiring trailing semicolon"); +# 26 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/contrib/algo/trans= form_test.cc" 2 +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/test_util-inl= .h" 1 +# 21 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/test_util-in= l.h" +# 1 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/hwy_gtest.h" 1 +# 21 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/hwy_gtest.h" +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 22 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/hwy_gtest.h"= 2 + + +# 1 "/usr/include/c++/13/string" 1 3 +# 36 "/usr/include/c++/13/string" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/string" 3 + + + + + +# 1 "/usr/include/c++/13/bits/char_traits.h" 1 3 +# 37 "/usr/include/c++/13/bits/char_traits.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/char_traits.h" 3 +# 46 "/usr/include/c++/13/bits/char_traits.h" 3 +# 1 "/usr/include/c++/13/cwchar" 1 3 +# 39 "/usr/include/c++/13/cwchar" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cwchar" 3 +# 47 "/usr/include/c++/13/bits/char_traits.h" 2 3 +# 64 "/usr/include/c++/13/bits/char_traits.h" 3 + +# 64 "/usr/include/c++/13/bits/char_traits.h" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + +=20 +# 68 "/usr/include/c++/13/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" +# 83 "/usr/include/c++/13/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; + + }; +# 110 "/usr/include/c++/13/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 =3D __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) + { return __c1 =3D=3D __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 =3D=3D __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 =3D 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 =3D 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 =3D 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + template +=20=20=20 + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + move(char_type* __s1, const char_type* __s2, std::size_t __n) + { + if (__n =3D=3D 0) + return __s1; +# 256 "/usr/include/c++/13/bits/char_traits.h" 3 + __builtin_memmove(__s1, __s2, __n * sizeof(char_type)); + return __s1; + } + + template +=20=20=20 + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + copy(char_type* __s1, const char_type* __s2, std::size_t __n) + { + if (__n =3D=3D 0) + return __s1; +# 276 "/usr/include/c++/13/bits/char_traits.h" 3 + __builtin_memcpy(__s1, __s2, __n * sizeof(char_type)); + return __s1; + } + + template +=20=20=20 + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + assign(char_type* __s, std::size_t __n, char_type __a) + { +# 295 "/usr/include/c++/13/bits/char_traits.h" 3 + if constexpr (sizeof(_CharT) =3D=3D 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 =3D 0; __i < __n; ++__i) + __s[__i] =3D __a; + } + return __s; + } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 340 "/usr/include/c++/13/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 =3D __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 =3D=3D __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 =3D=3D 0) + return 0; + + if (std::__is_constant_evaluated()) + { + for (size_t __i =3D 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 =3D=3D 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 =3D=3D 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 =3D=3D 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 =3D=3D 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 =3D=3D __c2; } + + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return (__c =3D=3D 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 =3D __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 =3D=3D __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 =3D=3D 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 =3D=3D 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 =3D=3D 0) + return __s1; + + + + + return wmemmove(__s1, __s2, __n); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n =3D=3D 0) + return __s1; + + + + + return wmemcpy(__s1, __s2, __n); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + if (__n =3D=3D 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 =3D=3D __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; } + + }; +# 750 "/usr/include/c++/13/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 =3D __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 =3D=3D __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 =3D 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 =3D 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 =3D 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 =3D=3D 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 =3D=3D 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 =3D 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 =3D=3D __c2; } + + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return __c =3D=3D 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 =3D __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 =3D=3D __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 =3D 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 =3D 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 =3D 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 =3D=3D 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 =3D=3D 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 =3D 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 =3D=3D __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; } + + }; +# 1032 "/usr/include/c++/13/bits/char_traits.h" 3 +#pragma GCC diagnostic pop + + +} +# 43 "/usr/include/c++/13/string" 2 3 + + +# 1 "/usr/include/c++/13/bits/localefwd.h" 1 3 +# 37 "/usr/include/c++/13/bits/localefwd.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/localefwd.h" 3 + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++locale.h" 1 3 +# 39 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++locale.h" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++locale.h" 3 + +# 1 "/usr/include/c++/13/clocale" 1 3 +# 39 "/usr/include/c++/13/clocale" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/clocale" 3 + + +# 1 "/usr/include/locale.h" 1 3 4 +# 28 "/usr/include/locale.h" 3 4 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/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 (tr= ue); + + +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); + + + + + + + +} +# 43 "/usr/include/c++/13/clocale" 2 3 +# 51 "/usr/include/c++/13/clocale" 3 +namespace std +{ + using ::lconv; + using ::setlocale; + using ::localeconv; +} +# 42 "/usr/include/riscv64-linux-gnu/c++/13/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++/13/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 =3D __gnu_cxx::__uselocale(__cloc); +# 93 "/usr/include/riscv64-linux-gnu/c++/13/bits/c++locale.h" 3 + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + + const int __ret =3D __builtin_vsnprintf(__out, __size, __fmt, __args); + + + + + __builtin_va_end(__args); + + + __gnu_cxx::__uselocale(__old); + + + + + + + + return __ret; + } + + + + + + + +} +# 41 "/usr/include/c++/13/bits/localefwd.h" 2 3 + +# 1 "/usr/include/c++/13/cctype" 1 3 +# 39 "/usr/include/c++/13/cctype" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cctype" 3 + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 28 "/usr/include/ctype.h" 3 4 +extern "C" { +# 46 "/usr/include/ctype.h" 3 4 +enum +{ + _ISupper =3D ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower =3D ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha =3D ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit =3D ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit =3D ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace =3D ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint =3D ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph =3D ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank =3D ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl =3D ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct =3D ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum =3D ((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 +} +# 43 "/usr/include/c++/13/cctype" 2 3 +# 62 "/usr/include/c++/13/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; +} +# 43 "/usr/include/c++/13/bits/localefwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 55 "/usr/include/c++/13/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++/13/string" 2 3 +# 1 "/usr/include/c++/13/bits/ostream_insert.h" 1 3 +# 33 "/usr/include/c++/13/bits/ostream_insert.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/ostream_insert.h" 3 + + +# 1 "/usr/include/c++/13/bits/cxxabi_forced.h" 1 3 +# 34 "/usr/include/c++/13/bits/cxxabi_forced.h" 3 +=20=20=20=20=20=20=20 +# 35 "/usr/include/c++/13/bits/cxxabi_forced.h" 3 + +#pragma GCC visibility push(default) + + +namespace __cxxabiv1 +{ + + + + + + + + class __forced_unwind + { + virtual ~__forced_unwind() throw(); + + + virtual void __pure_dummy() =3D 0; + }; +} + + +#pragma GCC visibility pop +# 37 "/usr/include/c++/13/bits/ostream_insert.h" 2 3 + + +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 =3D __out.rdbuf()->sputn(__s, __n); + if (__put !=3D __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 =3D __out.fill(); + for (; __n > 0; --__n) + { + const typename _Traits::int_type __put =3D __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) + { + if (true) + { + const streamsize __w =3D __out.width(); + if (__w > __n) + { + const bool __left =3D ((__out.flags() + & __ios_base::adjustfield) + =3D=3D __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); + } + if (false) + { + __out._M_setstate(__ios_base::badbit); + ; + } + if (false) + { __out._M_setstate(__ios_base::badbit); } + } + return __out; + } + + + + + extern template ostream& __ostream_insert(ostream&, const char*, streams= ize); + + + extern template wostream& __ostream_insert(wostream&, const wchar_t*, + streamsize); + + + + + + +} +# 47 "/usr/include/c++/13/string" 2 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/basic_string.h" 1 3 +# 37 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/basic_string.h" 3 +# 47 "/usr/include/c++/13/bits/basic_string.h" 3 +# 1 "/usr/include/c++/13/string_view" 1 3 +# 36 "/usr/include/c++/13/string_view" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/string_view" 3 +# 56 "/usr/include/c++/13/string_view" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 69 "/usr/include/c++/13/string_view" 3 + 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 " "(whi= ch 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 =3D __off < __size - __pos; + return __testoff ? __off : __size - __pos; + } +# 105 "/usr/include/c++/13/string_view" 3 + template> + class basic_string_view + { + static_assert(!is_array_v<_CharT>); + static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>); + static_assert(is_same_v<_CharT, typename _Traits::char_type>); + + public: + + + using traits_type =3D _Traits; + using value_type =3D _CharT; + using pointer =3D value_type*; + using const_pointer =3D const value_type*; + using reference =3D value_type&; + using const_reference =3D const value_type&; + using const_iterator =3D const value_type*; + using iterator =3D const_iterator; + using const_reverse_iterator =3D std::reverse_iterator; + using reverse_iterator =3D const_reverse_iterator; + using size_type =3D size_t; + using difference_type =3D ptrdiff_t; + static constexpr size_type npos =3D size_type(-1); + + + + constexpr + basic_string_view() noexcept + : _M_len{0}, _M_str{nullptr} + { } + + constexpr basic_string_view(const basic_string_view&) noexcept =3D d= efault; + + [[__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} + { } +# 182 "/usr/include/c++/13/string_view" 3 + constexpr basic_string_view& + operator=3D(const basic_string_view&) noexcept =3D 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 =3D=3D 0; } + + + + [[nodiscard]] + constexpr const_reference + operator[](size_type __pos) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__pos < this->_M_len)) _= _builtin_unreachable(); } while (false); + return *(this->_M_str + __pos); + } + + [[nodiscard]] + constexpr const_reference + at(size_type __pos) const + { + if (__pos >=3D _M_len) + __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %z= u) >=3D 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)) __bui= ltin_unreachable(); } while (false); + return *this->_M_str; + } + + [[nodiscard]] + constexpr const_reference + back() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) __bui= ltin_unreachable(); } 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 >=3D __n)) = __builtin_unreachable(); } while (false); + this->_M_str +=3D __n; + this->_M_len -=3D __n; + } + + constexpr void + remove_suffix(size_type __n) noexcept + { this->_M_len -=3D __n; } + + constexpr void + swap(basic_string_view& __sv) noexcept + { + auto __tmp =3D *this; + *this =3D __sv; + __sv =3D __tmp; + } + + + +=20=20=20=20=20 + size_type + copy(_CharT* __str, size_type __n, size_type __pos =3D 0) const + { + ; + __pos =3D std::__sv_check(size(), __pos, "basic_string_view::copy"); + const size_type __rlen =3D std::min(__n, _M_len - __pos); + + + traits_type::copy(__str, data() + __pos, __rlen); + return __rlen; + } + + [[nodiscard]] + constexpr basic_string_view + substr(size_type __pos =3D 0, size_type __n =3D npos) const noexcept= (false) + { + __pos =3D std::__sv_check(size(), __pos, "basic_string_view::substr"); + const size_type __rlen =3D 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 =3D std::min(this->_M_len, __str._M_len); + int __ret =3D traits_type::compare(this->_M_str, __str._M_str, __rlen); + if (__ret =3D=3D 0) + __ret =3D _S_compare(this->_M_len, __str._M_len); + return __ret; + } + + [[nodiscard]] + constexpr int + compare(size_type __pos1, size_type __n1, basic_string_view __str) c= onst + { 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)); + } +# 445 "/usr/include/c++/13/string_view" 3 + [[nodiscard]] + constexpr size_type + find(basic_string_view __str, size_type __pos =3D 0) const noexcept + { return this->find(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find(_CharT __c, size_type __pos =3D 0) const noexcept; + + [[nodiscard]] + constexpr size_type + find(const _CharT* __str, size_type __pos, size_type __n) const noex= cept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find(const _CharT* __str, size_type __pos =3D 0) const noexcept + { return this->find(__str, __pos, traits_type::length(__str)); } + + [[nodiscard]] + constexpr size_type + rfind(basic_string_view __str, size_type __pos =3D npos) const noexc= ept + { return this->rfind(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + rfind(_CharT __c, size_type __pos =3D npos) const noexcept; + + [[nodiscard]] + constexpr size_type + rfind(const _CharT* __str, size_type __pos, size_type __n) const noe= xcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + rfind(const _CharT* __str, size_type __pos =3D 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 =3D 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 =3D 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 =3D 0) const noex= cept + { 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 =3D 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=3Dnpos) 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 =3D npos) const no= except + { 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D npos) const noexcep= t; + + [[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 =3D 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 =3D __gnu_cxx::__int_traits; + const difference_type __diff =3D __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; + }; +# 605 "/usr/include/c++/13/string_view" 3 + template + [[nodiscard]] + constexpr bool + operator=3D=3D(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.size() =3D=3D __y.size() && __x.compare(__y) =3D=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator=3D=3D(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.size() =3D=3D __y.size() && __x.compare(__y) =3D=3D 0; } +# 638 "/usr/include/c++/13/string_view" 3 + template + [[nodiscard]] + constexpr bool + operator=3D=3D(__type_identity_t> _= _x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.size() =3D=3D __y.size() && __x.compare(__y) =3D=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator!=3D(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x =3D=3D __y); } + + template + [[nodiscard]] + constexpr bool + operator!=3D(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return !(__x =3D=3D __y); } + + template + [[nodiscard]] + constexpr bool + operator!=3D(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x =3D=3D __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<=3D(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator<=3D(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) <=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator<=3D(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator>=3D(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator>=3D(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) >=3D 0; } + + template + [[nodiscard]] + constexpr bool + operator>=3D(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >=3D 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 =3D basic_string_view; + using wstring_view =3D basic_string_view; + + + + using u16string_view =3D basic_string_view; + using u32string_view =3D 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 + { }; +# 825 "/usr/include/c++/13/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 + } + } +# 901 "/usr/include/c++/13/string_view" 3 + +} + +# 1 "/usr/include/c++/13/bits/string_view.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/string_view.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/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 noexce= pt + { + ; + + if (__n =3D=3D 0) + return __pos <=3D _M_len ? __pos : npos; + if (__pos >=3D _M_len) + return npos; + + const _CharT __elem0 =3D __str[0]; + const _CharT* __first =3D _M_str + __pos; + const _CharT* const __last =3D _M_str + _M_len; + size_type __len =3D _M_len - __pos; + + while (__len >=3D __n) + { + + __first =3D traits_type::find(__first, __len - __n + 1, __elem0); + if (!__first) + return npos; + + + + if (traits_type::compare(__first, __str, __n) =3D=3D 0) + return __first - _M_str; + __len =3D __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 =3D npos; + if (__pos < this->_M_len) + { + const size_type __n =3D this->_M_len - __pos; + const _CharT* __p =3D traits_type::find(this->_M_str + __pos, __n, __c); + if (__p) + __ret =3D __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 noexc= ept + { + ; + + if (__n <=3D this->_M_len) + { + __pos =3D std::min(size_type(this->_M_len - __n), __pos); + do + { + if (traits_type::compare(this->_M_str + __pos, __str, __n) =3D=3D 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 =3D this->_M_len; + if (__size > 0) + { + if (--__size > __pos) + __size =3D __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 =3D 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 =3D this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size =3D __pos; + do + { + if (traits_type::find(__str, __n, this->_M_str[__size])) + return __size; + } + while (__size-- !=3D 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 =3D this->_M_len; + if (__size) + { + if (--__size > __pos) + __size =3D __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 =3D this->_M_len; + if (__size) + { + if (--__size > __pos) + __size =3D __pos; + do + { + if (!traits_type::eq(this->_M_str[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + + +} +# 905 "/usr/include/c++/13/string_view" 2 3 +# 48 "/usr/include/c++/13/bits/basic_string.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { +# 84 "/usr/include/c++/13/bits/basic_string.h" 3 + template + class basic_string + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_CharT>::other _Char_alloc_type; + + + typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; +# 122 "/usr/include/c++/13/bits/basic_string.h" 3 + 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 =3D static_cast(-1); + + protected: + + + + + typedef const_iterator __const_iterator; + + + private: + + + typedef basic_string_view<_CharT, _Traits> __sv_type; + + template + using _If_sv =3D enable_if_t< + __and_, + __not_>, + __not_>>::value, + _Res>; + + +=20=20=20=20=20 + 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; + }; + + + + + + + +=20=20=20=20=20 + 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 =3D _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 =3D 15 / sizeof(_CharT) }; + + union + { + _CharT _M_local_buf[_S_local_capacity + 1]; + size_type _M_allocated_capacity; + }; + +=20=20=20=20=20 + void + _M_data(pointer __p) + { _M_dataplus._M_p =3D __p; } + +=20=20=20=20=20 + void + _M_length(size_type __length) + { _M_string_length =3D __length; } + +=20=20=20=20=20 + pointer + _M_data() const + { return _M_dataplus._M_p; } + +=20=20=20=20=20 + pointer + _M_local_data() + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + +=20=20=20=20=20 + const_pointer + _M_local_data() const + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + +=20=20=20=20=20 + void + _M_capacity(size_type __capacity) + { _M_allocated_capacity =3D __capacity; } + +=20=20=20=20=20 + void + _M_set_length(size_type __n) + { + _M_length(__n); + traits_type::assign(_M_data()[__n], _CharT()); + } + +=20=20=20=20=20 + bool + _M_is_local() const + { + if (_M_data() =3D=3D _M_local_data()) + { + if (_M_string_length > _S_local_capacity) + __builtin_unreachable(); + return true; + } + return false; + } + + +=20=20=20=20=20 + pointer + _M_create(size_type&, size_type); + +=20=20=20=20=20 + void + _M_dispose() + { + if (!_M_is_local()) + _M_destroy(_M_allocated_capacity); + } + +=20=20=20=20=20 + void + _M_destroy(size_type __size) throw() + { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + = 1); } +# 327 "/usr/include/c++/13/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); + +=20=20=20=20=20 + void + _M_construct(size_type __req, _CharT __c); + +=20=20=20=20=20 + allocator_type& + _M_get_allocator() + { return _M_dataplus; } + +=20=20=20=20=20 + const allocator_type& + _M_get_allocator() const + { return _M_dataplus; } + + + __attribute__((__always_inline__)) + constexpr + pointer + _M_use_local_data() noexcept + { + + + + + + return _M_local_data(); + } + + private: +# 385 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + 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; + } + +=20=20=20=20=20 + void + _M_check_length(size_type __n1, size_type __n2, const char* __s) con= st + { + if (this->max_size() - (this->size() - __n1) < __n2) + __throw_length_error((__s)); + } + + + +=20=20=20=20=20 + size_type + _M_limit(size_type __pos, size_type __off) const noexcept + { + const bool __testoff =3D __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)); + } + + + +=20=20=20=20=20 + static void + _S_copy(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n =3D=3D 1) + traits_type::assign(*__d, *__s); + else + traits_type::copy(__d, __s, __n); + } + +=20=20=20=20=20 + static void + _S_move(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n =3D=3D 1) + traits_type::assign(*__d, *__s); + else + traits_type::move(__d, __s, __n); + } + +=20=20=20=20=20 + static void + _S_assign(_CharT* __d, size_type __n, _CharT __c) + { + if (__n =3D=3D 1) + traits_type::assign(*__d, __c); + else + traits_type::assign(__d, __n, __c); + } + + + + template + + static void + _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) + { + for (; __k1 !=3D __k2; ++__k1, (void)++__p) + traits_type::assign(*__p, *__k1); + } + +=20=20=20=20=20 + static void + _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + +=20=20=20=20=20 + static void + _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) + noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + +=20=20=20=20=20 + static void + _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + +=20=20=20=20=20 + static void + _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) + noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + +=20=20=20=20=20 + static int + _S_compare(size_type __n1, size_type __n2) noexcept + { + const difference_type __d =3D 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); + } + +=20=20=20=20=20 + void + _M_assign(const basic_string&); + +=20=20=20=20=20 + void + _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, + size_type __len2); + +=20=20=20=20=20 + void + _M_erase(size_type __pos, size_type __n); + + public: + + + + + + + +=20=20=20=20=20 + basic_string() + noexcept(is_nothrow_default_constructible<_Alloc>::value) + : _M_dataplus(_M_local_data()) + { + _M_use_local_data(); + _M_set_length(0); + } + + + + +=20=20=20=20=20 + explicit + basic_string(const _Alloc& __a) noexcept + : _M_dataplus(_M_local_data(), __a) + { + _M_use_local_data(); + _M_set_length(0); + } + + + + + +=20=20=20=20=20 + 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._M_data() + __str.length(), + std::forward_iterator_tag()); + } +# 564 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string(const basic_string& __str, size_type __pos, + const _Alloc& __a =3D _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + const _CharT* __start =3D __str._M_data() + + __str._M_check(__pos, "basic_string::basic_string"); + _M_construct(__start, __start + __str._M_limit(__pos, npos), + std::forward_iterator_tag()); + } + + + + + + + +=20=20=20=20=20 + basic_string(const basic_string& __str, size_type __pos, + size_type __n) + : _M_dataplus(_M_local_data()) + { + const _CharT* __start =3D __str._M_data() + + __str._M_check(__pos, "basic_string::basic_string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n), + std::forward_iterator_tag()); + } +# 599 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string(const basic_string& __str, size_type __pos, + size_type __n, const _Alloc& __a) + : _M_dataplus(_M_local_data(), __a) + { + const _CharT* __start + =3D __str._M_data() + __str._M_check(__pos, "string::string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n), + std::forward_iterator_tag()); + } +# 619 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string(const _CharT* __s, size_type __n, + const _Alloc& __a =3D _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + + if (__s =3D=3D 0 && __n > 0) + std::__throw_logic_error(("basic_string: " "construction from null is n= ot valid") + ); + _M_construct(__s, __s + __n, std::forward_iterator_tag()); + } +# 639 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + +=20=20=20=20=20 + basic_string(const _CharT* __s, const _Alloc& __a =3D _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + + if (__s =3D=3D 0) + std::__throw_logic_error(("basic_string: " "construction from null is n= ot valid") + ); + const _CharT* __end =3D __s + traits_type::length(__s); + _M_construct(__s, __end, forward_iterator_tag()); + } +# 662 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + +=20=20=20=20=20 + basic_string(size_type __n, _CharT __c, const _Alloc& __a =3D _Alloc= ()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__n, __c); } +# 677 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string(basic_string&& __str) noexcept + : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) + { + if (__str._M_is_local()) + { + 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_local_data()); + __str._M_set_length(0); + } + + + + + + +=20=20=20=20=20 + basic_string(initializer_list<_CharT> __l, const _Alloc& __a =3D _Al= loc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag());= } + +=20=20=20=20=20 + 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= ()); } + +=20=20=20=20=20 + 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()) + { + 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() =3D=3D __a) + { + _M_data(__str._M_data()); + _M_length(__str.length()); + _M_capacity(__str._M_allocated_capacity); + __str._M_data(__str._M_local_buf); + __str._M_set_length(0); + } + else + _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); + } +# 753 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + + + + + basic_string(_InputIterator __beg, _InputIterator __end, + const _Alloc& __a =3D _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + + _M_construct(__beg, __end, std::__iterator_category(__beg)); + + + + + } +# 779 "/usr/include/c++/13/bits/basic_string.h" 3 + template>> + + basic_string(const _Tp& __t, size_type __pos, size_type __n, + const _Alloc& __a =3D _Alloc()) + : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { } + + + + + + + template> + + explicit + basic_string(const _Tp& __t, const _Alloc& __a =3D _Alloc()) + : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { } + + + + + +=20=20=20=20=20 + ~basic_string() + { _M_dispose(); } + + + + + +=20=20=20=20=20 + basic_string& + operator=3D(const basic_string& __str) + { + return this->assign(__str); + } + + + + + +=20=20=20=20=20 + basic_string& + operator=3D(const _CharT* __s) + { return this->assign(__s); } +# 832 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + operator=3D(_CharT __c) + { + this->assign(1, __c); + return *this; + } +# 850 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + operator=3D(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + const bool __equal_allocs =3D _Alloc_traits::_S_always_equal() + || _M_get_allocator() =3D=3D __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) !=3D 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 =3D nullptr; + size_type __capacity; + if (!_M_is_local()) + { + if (__equal_allocs) + { + + __data =3D _M_data(); + __capacity =3D _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_local_buf); + } + else + assign(__str); + __str.clear(); + return *this; + } + + + + + +=20=20=20=20=20 + basic_string& + operator=3D(initializer_list<_CharT> __l) + { + this->assign(__l.begin(), __l.size()); + return *this; + } + + + + + + + + template +=20=20=20=20=20=20 + _If_sv<_Tp, basic_string&> + operator=3D(const _Tp& __svt) + { return this->assign(__svt); } + + + + + +=20=20=20=20=20 + 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 + { return _M_string_length; } + + + + [[__nodiscard__]] + size_type + length() const noexcept + { return _M_string_length; } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; } +# 1096 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + void + resize(size_type __n, _CharT __c); +# 1110 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + void + resize(size_type __n) + { this->resize(__n, _CharT()); } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +=20=20=20=20=20 + void + shrink_to_fit() noexcept + { reserve(); } +#pragma GCC diagnostic pop +# 1166 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + capacity() const noexcept + { + return _M_is_local() ? size_type(_S_local_capacity) + : _M_allocated_capacity; + } +# 1191 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + void + reserve(size_type __res_arg); + + + + + + + +=20=20=20=20=20 + void + reserve(); + + + + +=20=20=20=20=20 + void + clear() noexcept + { _M_set_length(0); } + + + + + + [[__nodiscard__]] + bool + empty() const noexcept + { return this->size() =3D=3D 0; } +# 1233 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + const_reference + operator[] (size_type __pos) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__pos <=3D size())) __bu= iltin_unreachable(); } while (false); + return _M_data()[__pos]; + } +# 1251 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + reference + operator[](size_type __pos) + { + + + do { if (std::__is_constant_evaluated() && !bool(__pos <=3D size())) __bu= iltin_unreachable(); } while (false); + + ; + return _M_data()[__pos]; + } +# 1273 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + const_reference + at(size_type __n) const + { + if (__n >=3D this->size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >=3D= this->size() " "(which is %zu)") + + , + __n, this->size()); + return _M_data()[__n]; + } +# 1295 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + reference + at(size_type __n) + { + if (__n >=3D size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >=3D= this->size() " "(which is %zu)") + + , + __n, this->size()); + return _M_data()[__n]; + } + + + + + + + [[__nodiscard__]] + reference + front() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unr= eachable(); } while (false); + return operator[](0); + } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unr= eachable(); } while (false); + return operator[](0); + } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unr= eachable(); } while (false); + return operator[](this->size() - 1); + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unr= eachable(); } while (false); + return operator[](this->size() - 1); + } +# 1363 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + operator+=3D(const basic_string& __str) + { return this->append(__str); } + + + + + + +=20=20=20=20=20 + basic_string& + operator+=3D(const _CharT* __s) + { return this->append(__s); } + + + + + + +=20=20=20=20=20 + basic_string& + operator+=3D(_CharT __c) + { + this->push_back(__c); + return *this; + } + + + + + + + +=20=20=20=20=20 + basic_string& + operator+=3D(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +# 1409 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + operator+=3D(const _Tp& __svt) + { return this->append(__svt); } + + + + + + + +=20=20=20=20=20 + basic_string& + append(const basic_string& __str) + { return this->append(__str._M_data(), __str.size()); } +# 1439 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + append(const basic_string& __str, size_type __pos, size_type __n =3D= npos) + { return this->append(__str._M_data() + + __str._M_check(__pos, "basic_string::append"), + __str._M_limit(__pos, __n)); } + + + + + + + +=20=20=20=20=20 + basic_string& + append(const _CharT* __s, size_type __n) + { + ; + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } + + + + + + +=20=20=20=20=20 + basic_string& + append(const _CharT* __s) + { + ; + const size_type __n =3D traits_type::length(__s); + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } +# 1484 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + append(size_type __n, _CharT __c) + { return _M_replace_aux(this->size(), size_type(0), __n, __c); } + + + + + + + +=20=20=20=20=20 + basic_string& + append(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +# 1510 "/usr/include/c++/13/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 =3D __svt; + return this->append(__sv.data(), __sv.size()); + } +# 1542 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + append(const _Tp& __svt, size_type __pos, size_type __n =3D npos) + { + __sv_type __sv =3D __svt; + return _M_append(__sv.data() + + std::__sv_check(__sv.size(), __pos, "basic_string::append"), + std::__sv_limit(__sv.size(), __pos, __n)); + } + + + + + + +=20=20=20=20=20 + void + push_back(_CharT __c) + { + const size_type __size =3D 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); + } + + + + + + +=20=20=20=20=20 + 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() !=3D __str._M_get_allocator()) + { + + + if (__str.size() <=3D _S_local_capacity) + { + _M_destroy(_M_allocated_capacity); + _M_data(_M_use_local_data()); + _M_set_length(0); + } + else + { + const auto __len =3D __str.size(); + auto __alloc =3D __str._M_get_allocator(); + + auto __ptr =3D _Alloc_traits::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; + } +# 1620 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + assign(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + + + return *this =3D std::move(__str); + } +# 1644 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n =3D= npos) + { return _M_replace(size_type(0), this->size(), __str._M_data() + + __str._M_check(__pos, "basic_string::assign"), + __str._M_limit(__pos, __n)); } +# 1661 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + assign(const _CharT* __s, size_type __n) + { + ; + return _M_replace(size_type(0), this->size(), __s, __n); + } +# 1678 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + assign(const _CharT* __s) + { + ; + return _M_replace(size_type(0), this->size(), __s, + traits_type::length(__s)); + } +# 1696 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + assign(size_type __n, _CharT __c) + { return _M_replace_aux(size_type(0), this->size(), __n, __c); } +# 1710 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + + + + + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { return this->replace(begin(), end(), __first, __last); } + + + + + + + +=20=20=20=20=20 + basic_string& + assign(initializer_list<_CharT> __l) + { return this->assign(__l.begin(), __l.size()); } +# 1738 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + assign(const _Tp& __svt) + { + __sv_type __sv =3D __svt; + return this->assign(__sv.data(), __sv.size()); + } +# 1754 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + assign(const _Tp& __svt, size_type __pos, size_type __n =3D npos) + { + __sv_type __sv =3D __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)); + } +# 1783 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __p, size_type __n, _CharT __c) + { + ; + const size_type __pos =3D __p - begin(); + this->replace(__p, __p, __n, __c); + return iterator(this->_M_data() + __pos); + } +# 1826 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + + iterator + insert(const_iterator __p, _InputIterator __beg, _InputIterator __= end) + { + ; + const size_type __pos =3D __p - begin(); + this->replace(__p, __p, __beg, __end); + return iterator(this->_M_data() + __pos); + } +# 1863 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + iterator + insert(const_iterator __p, initializer_list<_CharT> __l) + { return this->insert(__p, __l.begin(), __l.end()); } +# 1891 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + insert(size_type __pos1, const basic_string& __str) + { return this->replace(__pos1, size_type(0), + __str._M_data(), __str.size()); } +# 1915 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n =3D npos) + { return this->replace(__pos1, size_type(0), __str._M_data() + + __str._M_check(__pos2, "basic_string::insert"), + __str._M_limit(__pos2, __n)); } +# 1939 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n) + { return this->replace(__pos, size_type(0), __s, __n); } +# 1959 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + insert(size_type __pos, const _CharT* __s) + { + ; + return this->replace(__pos, size_type(0), __s, + traits_type::length(__s)); + } +# 1984 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + 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); } +# 2003 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + iterator + insert(__const_iterator __p, _CharT __c) + { + ; + const size_type __pos =3D __p - begin(); + _M_replace_aux(__pos, size_type(0), size_type(1), __c); + return iterator(_M_data() + __pos); + } +# 2020 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + insert(size_type __pos, const _Tp& __svt) + { + __sv_type __sv =3D __svt; + return this->insert(__pos, __sv.data(), __sv.size()); + } +# 2037 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + insert(size_type __pos1, const _Tp& __svt, + size_type __pos2, size_type __n =3D npos) + { + __sv_type __sv =3D __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)); + } +# 2066 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + erase(size_type __pos =3D 0, size_type __n =3D npos) + { + _M_check(__pos, "basic_string::erase"); + if (__n =3D=3D npos) + this->_M_set_length(__pos); + else if (__n !=3D 0) + this->_M_erase(__pos, _M_limit(__pos, __n)); + return *this; + } +# 2086 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + iterator + erase(__const_iterator __position) + { + + ; + const size_type __pos =3D __position - begin(); + this->_M_erase(__pos, size_type(1)); + return iterator(_M_data() + __pos); + } +# 2106 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + iterator + erase(__const_iterator __first, __const_iterator __last) + { + + ; + const size_type __pos =3D __first - begin(); + if (__last =3D=3D end()) + this->_M_set_length(__pos); + else + this->_M_erase(__pos, __last - __first); + return iterator(this->_M_data() + __pos); + } + + + + + + + +=20=20=20=20=20 + void + pop_back() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unr= eachable(); } while (false); + _M_erase(size() - 1, 1); + } +# 2152 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(size_type __pos, size_type __n, const basic_string& __str) + { return this->replace(__pos, __n, __str._M_data(), __str.size()); } +# 2175 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2 =3D npos) + { return this->replace(__pos1, __n1, __str._M_data() + + __str._M_check(__pos2, "basic_string::replace"), + __str._M_limit(__pos2, __n2)); } +# 2201 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + 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); + } +# 2227 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s) + { + ; + return this->replace(__pos, __n1, __s, traits_type::length(__s)); + } +# 2252 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + 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); } +# 2271 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const basic_string& __str) + { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } +# 2292 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const _CharT* __s, size_type __n) + { + + ; + return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); + } +# 2315 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, const _CharT* = __s) + { + ; + return this->replace(__i1, __i2, __s, traits_type::length(__s)); + } +# 2337 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, size_type __n, + _CharT __c) + { + + ; + return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); + } +# 2363 "/usr/include/c++/13/bits/basic_string.h" 3 + template> + + basic_string& + replace(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2) + { +=20=20 + ; + ; + return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, + std::__false_type()); + } +# 2396 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + _CharT* __k1, _CharT* __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1, __k2 - __k1); + } + +=20=20=20=20=20 + 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); + } + +=20=20=20=20=20 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + iterator __k1, iterator __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } + +=20=20=20=20=20 + 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); + } +# 2459 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + basic_string& replace(const_iterator __i1, const_iterator __i2, + initializer_list<_CharT> __l) + { return this->replace(__i1, __i2, __l.begin(), __l.size()); } +# 2473 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + replace(size_type __pos, size_type __n, const _Tp& __svt) + { + __sv_type __sv =3D __svt; + return this->replace(__pos, __n, __sv.data(), __sv.size()); + } +# 2491 "/usr/include/c++/13/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 =3D npos) + { + __sv_type __sv =3D __svt; + return this->replace(__pos1, __n1, + __sv.data() + + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"), + std::__sv_limit(__sv.size(), __pos2, __n2)); + } +# 2513 "/usr/include/c++/13/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt) + { + __sv_type __sv =3D __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); + +=20=20=20=20=20 + 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); + +=20=20=20=20=20 + basic_string& + _M_replace(size_type __pos, size_type __len1, const _CharT* __s, + const size_type __len2); + +=20=20=20=20=20 + basic_string& + _M_append(const _CharT* __s, size_type __n); + + public: +# 2570 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + size_type + copy(_CharT* __s, size_type __n, size_type __pos =3D 0) const; +# 2581 "/usr/include/c++/13/bits/basic_string.h" 3 +=20=20=20=20=20 + void + swap(basic_string& __s) noexcept; +# 2592 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + const _CharT* + c_str() const noexcept + { return _M_data(); } +# 2605 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + const _CharT* + data() const noexcept + { return _M_data(); } +# 2617 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + _CharT* + data() noexcept + { return _M_data(); } + + + + + + [[__nodiscard__]] + allocator_type + get_allocator() const noexcept + { return _M_get_allocator(); } +# 2643 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2658 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const basic_string& __str, size_type __pos =3D 0) const + noexcept + { return this->find(__str.data(), __pos, __str.size()); } +# 2671 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find(const _Tp& __svt, size_type __pos =3D 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->find(__sv.data(), __pos, __sv.size()); + } +# 2692 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const _CharT* __s, size_type __pos =3D 0) const noexcept + { + ; + return this->find(__s, __pos, traits_type::length(__s)); + } +# 2710 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(_CharT __c, size_type __pos =3D 0) const noexcept; +# 2724 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const basic_string& __str, size_type __pos =3D npos) const + noexcept + { return this->rfind(__str.data(), __pos, __str.size()); } +# 2737 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + rfind(const _Tp& __svt, size_type __pos =3D npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->rfind(__sv.data(), __pos, __sv.size()); + } +# 2760 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2775 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const _CharT* __s, size_type __pos =3D npos) const + { + ; + return this->rfind(__s, __pos, traits_type::length(__s)); + } +# 2793 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(_CharT __c, size_type __pos =3D npos) const noexcept; +# 2808 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const basic_string& __str, size_type __pos =3D 0) const + noexcept + { return this->find_first_of(__str.data(), __pos, __str.size()); } +# 2822 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_first_of(const _Tp& __svt, size_type __pos =3D 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->find_first_of(__sv.data(), __pos, __sv.size()); + } +# 2845 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) con= st + noexcept; +# 2860 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const _CharT* __s, size_type __pos =3D 0) const + noexcept + { + ; + return this->find_first_of(__s, __pos, traits_type::length(__s)); + } +# 2881 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(_CharT __c, size_type __pos =3D 0) const noexcept + { return this->find(__c, __pos); } +# 2897 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const basic_string& __str, size_type __pos =3D npos) co= nst + noexcept + { return this->find_last_of(__str.data(), __pos, __str.size()); } +# 2911 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_last_of(const _Tp& __svt, size_type __pos =3D npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->find_last_of(__sv.data(), __pos, __sv.size()); + } +# 2934 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2949 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const _CharT* __s, size_type __pos =3D npos) const + noexcept + { + ; + return this->find_last_of(__s, __pos, traits_type::length(__s)); + } +# 2970 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(_CharT __c, size_type __pos =3D npos) const noexcept + { return this->rfind(__c, __pos); } +# 2985 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const basic_string& __str, size_type __pos =3D 0) = const + noexcept + { return this->find_first_not_of(__str.data(), __pos, __str.size());= } +# 2999 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_first_not_of(const _Tp& __svt, size_type __pos =3D 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->find_first_not_of(__sv.data(), __pos, __sv.size()); + } +# 3022 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const _CharT* __s, size_type __pos, + size_type __n) const noexcept; +# 3037 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const _CharT* __s, size_type __pos =3D 0) const + noexcept + { + ; + return this->find_first_not_of(__s, __pos, traits_type::length(__s)); + } +# 3056 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(_CharT __c, size_type __pos =3D 0) const + noexcept; +# 3072 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const basic_string& __str, size_type __pos =3D npos= ) const + noexcept + { return this->find_last_not_of(__str.data(), __pos, __str.size()); } +# 3086 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_last_not_of(const _Tp& __svt, size_type __pos =3D npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return this->find_last_not_of(__sv.data(), __pos, __sv.size()); + } +# 3109 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const _CharT* __s, size_type __pos, + size_type __n) const noexcept; +# 3124 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const _CharT* __s, size_type __pos =3D npos) const + noexcept + { + ; + return this->find_last_not_of(__s, __pos, traits_type::length(__s)); + } +# 3143 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(_CharT __c, size_type __pos =3D npos) const + noexcept; +# 3160 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + basic_string + substr(size_type __pos =3D 0, size_type __n =3D npos) const + { return basic_string(*this, + _M_check(__pos, "basic_string::substr"), __n); } +# 3180 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(const basic_string& __str) const + { + const size_type __size =3D this->size(); + const size_type __osize =3D __str.size(); + const size_type __len =3D std::min(__size, __osize); + + int __r =3D traits_type::compare(_M_data(), __str.data(), __len); + if (!__r) + __r =3D _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 =3D __svt; + const size_type __size =3D this->size(); + const size_type __osize =3D __sv.size(); + const size_type __len =3D std::min(__size, __osize); + + int __r =3D traits_type::compare(_M_data(), __sv.data(), __len); + if (!__r) + __r =3D _S_compare(__size, __osize); + return __r; + } +# 3225 "/usr/include/c++/13/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 =3D __svt; + return __sv_type(*this).substr(__pos, __n).compare(__sv); + } +# 3245 "/usr/include/c++/13/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 =3D npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv =3D __svt; + return __sv_type(*this) + .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); + } +# 3277 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos, size_type __n, const basic_string& __str) c= onst + { + _M_check(__pos, "basic_string::compare"); + __n =3D _M_limit(__pos, __n); + const size_type __osize =3D __str.size(); + const size_type __len =3D std::min(__n, __osize); + int __r =3D traits_type::compare(_M_data() + __pos, __str.data(), __len); + if (!__r) + __r =3D _S_compare(__n, __osize); + return __r; + } +# 3314 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2 =3D npos) const + { + _M_check(__pos1, "basic_string::compare"); + __str._M_check(__pos2, "basic_string::compare"); + __n1 =3D _M_limit(__pos1, __n1); + __n2 =3D __str._M_limit(__pos2, __n2); + const size_type __len =3D std::min(__n1, __n2); + int __r =3D traits_type::compare(_M_data() + __pos1, + __str.data() + __pos2, __len); + if (!__r) + __r =3D _S_compare(__n1, __n2); + return __r; + } +# 3345 "/usr/include/c++/13/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(const _CharT* __s) const noexcept + { + ; + const size_type __size =3D this->size(); + const size_type __osize =3D traits_type::length(__s); + const size_type __len =3D std::min(__size, __osize); + int __r =3D traits_type::compare(_M_data(), __s, __len); + if (!__r) + __r =3D _S_compare(__size, __osize); + return __r; + } +# 3380 "/usr/include/c++/13/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 =3D _M_limit(__pos, __n1); + const size_type __osize =3D traits_type::length(__s); + const size_type __len =3D std::min(__n1, __osize); + int __r =3D traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r =3D _S_compare(__n1, __osize); + return __r; + } +# 3419 "/usr/include/c++/13/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 =3D _M_limit(__pos, __n1); + const size_type __len =3D std::min(__n1, __n2); + int __r =3D traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r =3D _S_compare(__n1, __n2); + return __r; + } +# 3484 "/usr/include/c++/13/bits/basic_string.h" 3 + template friend class basic_stringbuf; + }; +} + +} + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +namespace __cxx11 { + template::value_type, + typename _Allocator =3D allocator<_CharT>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireAllocator<_Allocator>> + basic_string(_InputIterator, _InputIterator, _Allocator =3D _Allocator= ()) + -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; + + + + template, + typename =3D _RequireAllocator<_Allocator>> + basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& =3D= _Allocator()) + -> basic_string<_CharT, _Traits, _Allocator>; + + template, + typename =3D _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& =3D _Allocator()) + -> basic_string<_CharT, _Traits, _Allocator>; +} + + + template +=20=20=20 + 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; + } +# 3549 "/usr/include/c++/13/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>& __r= hs) + { + 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 +=20=20=20 + 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 =3D allocator_traits<_Alloc>; + bool __use_rhs =3D false; + if constexpr (typename _Alloc_traits::is_always_equal{}) + __use_rhs =3D true; + else if (__lhs.get_allocator() =3D=3D __rhs.get_allocator()) + __use_rhs =3D true; + if (__use_rhs) + + { + const auto __size =3D __lhs.size() + __rhs.size(); + if (__size > __lhs.capacity() && __size <=3D __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)); } +# 3706 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { + return __lhs.size() =3D=3D __rhs.size() + && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size()); + } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { + return __lhs.size() =3D=3D _Traits::length(__rhs) + && !_Traits::compare(__lhs.data(), __rhs, __lhs.size()); + } +# 3770 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs =3D=3D __lhs; } +# 3784 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator!=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return !(__lhs =3D=3D __rhs); } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator!=3D(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__rhs =3D=3D __lhs); } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator!=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return !(__lhs =3D=3D __rhs); } +# 3825 "/usr/include/c++/13/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; } +# 3866 "/usr/include/c++/13/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; } +# 3907 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator<=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) <=3D 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) <=3D 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<=3D(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) >=3D 0; } +# 3948 "/usr/include/c++/13/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator>=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) >=3D 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>=3D(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) >=3D 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>=3D(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) <=3D 0; } +# 3990 "/usr/include/c++/13/bits/basic_string.h" 3 + template +=20=20=20 + inline void + swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept(noexcept(__lhs.swap(__rhs))) + { __lhs.swap(__rhs); } +# 4011 "/usr/include/c++/13/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); +# 4029 "/usr/include/c++/13/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()); + } +# 4052 "/usr/include/c++/13/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); +# 4069 "/usr/include/c++/13/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++/13/ext/string_conversions.h" 1 3 +# 32 "/usr/include/c++/13/ext/string_conversions.h" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/ext/string_conversions.h" 3 +# 43 "/usr/include/c++/13/ext/string_conversions.h" 3 +# 1 "/usr/include/c++/13/cstdlib" 1 3 +# 39 "/usr/include/c++/13/cstdlib" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cstdlib" 3 +# 125 "/usr/include/c++/13/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); } + + + + +} +# 199 "/usr/include/c++/13/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot =3D __n / __d; __q.rem =3D __n % __d; return __q= ; } + + using ::lldiv; +# 231 "/usr/include/c++/13/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; +} + + + +} +# 44 "/usr/include/c++/13/ext/string_conversions.h" 2 3 +# 1 "/usr/include/c++/13/cwchar" 1 3 +# 39 "/usr/include/c++/13/cwchar" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cwchar" 3 +# 45 "/usr/include/c++/13/ext/string_conversions.h" 2 3 +# 1 "/usr/include/c++/13/cstdio" 1 3 +# 39 "/usr/include/c++/13/cstdio" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cstdio" 3 + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 27 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/stdio.h" 2 3 4 + +extern "C" { + + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stdarg.h" 1 3 4 +# 37 "/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; +# 40 "/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; +# 41 "/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 +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; + __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; + size_t __pad5; + int _mode; + + char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; +}; +# 44 "/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 *__b= uf, + 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; +# 47 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 84 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 133 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/stdio_lim.h" 1 3 4 +# 134 "/usr/include/stdio.h" 2 3 4 +# 143 "/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); +# 170 "/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); +# 188 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __= attribute__ ((__warn_unused_result__)); +# 200 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) _= _attribute__ ((__warn_unused_result__)); + + + +extern char *tmpnam (char[20]) noexcept (true) __attribute__ ((__warn_unus= ed_result__)); + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) __attribute__ ((__war= n_unused_result__)); +# 222 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__warn_unu= sed_result__)) __attribute__ ((__malloc__ (__builtin_free, 1))); + + + + + + +extern int fflush (FILE *__stream); +# 239 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 249 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 258 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) __= attribute__ ((__warn_unused_result__)); + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)= ); +# 283 "/usr/include/stdio.h" 3 4 +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__)); + + + + +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) noe= xcept (true) + __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))); + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noe= xcept (true); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true); + + +extern void setlinebuf (FILE *__stream) noexcept (true); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +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); + + + + +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))) __att= ribute__ ((__warn_unused_result__)); +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) __att= ribute__ ((__warn_unused_result__)); +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) __att= ribute__ ((__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_r= esult__)); + + + + +extern int scanf (const char *__restrict __format, ...) __attribute__ ((__= warn_unused_result__)); + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); +# 434 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, const char *__restrict __for= mat, ...) __asm__ ("" "__isoc99_fscanf") + + __attribute__ ((__warn_unused_result__)); +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__iso= c99_scanf") + __attribute__ ((__warn_unused_result__)); +extern int sscanf (const char *__restrict __s, const char *__restrict __fo= rmat, ...) noexcept (true) __asm__ ("" "__isoc99_sscanf") + + ; +# 459 "/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__)); + + + + + +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__ ("" "__isoc99_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn= _unused_result__)); +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) = __asm__ ("" "__isoc99_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn= _unused_result__)); +extern int vsscanf (const char *__restrict __s, const char *__restrict __f= ormat, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 513 "/usr/include/stdio.h" 3 4 +extern int fgetc (FILE *__stream); +extern int getc (FILE *__stream); + + + + + +extern int getchar (void); + + + + + + +extern int getc_unlocked (FILE *__stream); +extern int getchar_unlocked (void); +# 538 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 549 "/usr/include/stdio.h" 3 4 +extern int fputc (int __c, FILE *__stream); +extern int putc (int __c, FILE *__stream); + + + + + +extern int putchar (int __c); +# 565 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream); + + +extern int putw (int __w, FILE *__stream); + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stre= am) + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (= __write_only__, 1, 2))); +# 615 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 1, 2))); +# 632 "/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__)); +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) __attribute__ ((__wa= rn_unused_result__)); + + + + + + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) __attribute__ ((__war= n_unused_result__)); + + + + + + + +extern int fputs (const char *__restrict __s, FILE *__restrict __stream); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unuse= d_result__)); + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s); +# 691 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 702 "/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_unu= sed_result__)); +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream); + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence); + + + + +extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_resul= t__)); + + + + +extern void rewind (FILE *__stream); +# 736 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_resul= t__)); +# 760 "/usr/include/stdio.h" 3 4 +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos); +# 779 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_r= esult__)); +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __po= s); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + +extern void clearerr (FILE *__stream) noexcept (true); + +extern int feof (FILE *__stream) noexcept (true) __attribute__ ((__warn_un= used_result__)); + +extern int ferror (FILE *__stream) noexcept (true) __attribute__ ((__warn_= unused_result__)); + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true); +extern int feof_unlocked (FILE *__stream) noexcept (true) __attribute__ ((= __warn_unused_result__)); +extern int ferror_unlocked (FILE *__stream) noexcept (true) __attribute__ = ((__warn_unused_result__)); + + + + + + + +extern void perror (const char *__s); + + + + +extern int fileno (FILE *__stream) noexcept (true) __attribute__ ((__warn_= unused_result__)); + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) __attribute__ = ((__warn_unused_result__)); +# 823 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream); + + + + + +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); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) __attribute__ ((_= _warn_unused_result__)); + + +extern void funlockfile (FILE *__stream) noexcept (true); +# 885 "/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, ...); +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); +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 __f= mt, + ...) __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))) __att= ribute__ ((__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))) __att= ribute__ ((__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))); +# 90 "/usr/include/riscv64-linux-gnu/bits/stdio2-decl.h" 3 4 +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))); + +extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, + FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)); + + +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))); + + + + +extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrle= n, + size_t __size, size_t __n, + FILE *__restrict __stream) __attribute__ ((__warn_unused_result__)= ); +# 891 "/usr/include/stdio.h" 2 3 4 +# 902 "/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 >=3D (__fp)->_IO_read_en= d), 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 >=3D (__fp)->_IO_read_en= d), 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 >=3D (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 >=3D (__stream)->_I= O_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned= char) (*(__stream)->_IO_write_ptr++ =3D (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >=3D (__stream)->_I= O_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned= char) (*(__stream)->_IO_write_ptr++ =3D (__c))); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar_unlocked (int __c) +{ + return (__builtin_expect (((stdout)->_IO_write_ptr >=3D (stdout)->_IO_wr= ite_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char)= (*(stdout)->_IO_write_ptr++ =3D (__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) !=3D 0); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0020) !=3D 0); +} +# 903 "/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 *__re= strict __fmt, ...) noexcept (true) +{ + return __builtin___sprintf_chk (__s, 2 - 1, + __builtin_object_size (__s, 2 > 1), __fmt, + __builtin_va_arg_pack ()); +} + + + + + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) vsprintf (char *__restrict __s, const char *__r= estrict __fmt, __gnuc_va_list __ap) noexcept (true) + +{ + return __builtin___vsprintf_chk (__s, 2 - 1, + __builtin_object_size (__s, 2 > 1), __fmt, __ap); +} + + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) snprintf (char *__restrict __s, size_t __n, con= st char *__restrict __fmt, ...) noexcept (true) + +{ + return __builtin___snprintf_chk (__s, __n, 2 - 1, + __builtin_object_size (__s, 2 > 1), __fmt, + __builtin_va_arg_pack ()); +} + + + + + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) vsnprintf (char *__restrict __s, size_t __n, co= nst char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) + +{ + return __builtin___vsnprintf_chk (__s, __n, 2 - 1, + __builtin_object_size (__s, 2 > 1), __fmt, __ap); +} + + + + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) +{ + return __fprintf_chk (__stream, 2 - 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 (2 - 1, __fmt, __builtin_va_arg_pack ()); +} + + + + + + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +vprintf (const char *__restrict __fmt, __gnuc_va_list __ap) +{ + + return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap); + + + +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +vfprintf (FILE *__restrict __stream, + const char *__restrict __fmt, __gnuc_va_list __ap) +{ + return __vfprintf_chk (__stream, 2 - 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, 2 - 1, __fmt, + __builtin_va_arg_pack ()); +} + + + + + +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, 2 - 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, 2 - 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, 2 - 1, __fmt, + __builtin_va_arg_pack ()); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) obstack_printf (struct obstack *__restrict __ob= stack, const char *__restrict __fmt, ...) noexcept (true) + +{ + return __obstack_printf_chk (__obstack, 2 - 1, __fmt, + __builtin_va_arg_pack ()); +} +# 165 "/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, 2 - 1, __fmt, __ap); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) obstack_vprintf (struct obstack *__restrict __o= bstack, const char *__restrict __fmt, __gnuc_va_list __ap) noexcept (true) + +{ + return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt, + __ap); +} +# 198 "/usr/include/riscv64-linux-gnu/bits/stdio2.h" 3 4 +extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restric= t __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 __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) __attribute__ ((__access__ (__write_only__, 1, 2))) char * +fgets (char *__restrict __s, int __n, FILE *__restrict __stream) +{ + size_t sz =3D __builtin_object_size (__s, 2 > 1); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((sizeof (char))))) && (((long unsigned int) (__n)) <=3D ((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)) = <=3D (sz) / (sizeof (char)))) && !(((long unsigned int) (__n)) <=3D (sz) / = (sizeof (char))))) + return __fgets_chk_warn (__s, sz, __n, __stream); + return __fgets_chk (__s, sz, __n, __stream); +} + +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, s= ize_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_c= hk") + + + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "fread called with bigger size * nmemb than length " "of destination buffer= "))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) size_t +fread (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) +{ + size_t sz =3D __builtin_object_size (__ptr, 0); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((__size)))) && (((long unsigned int) (__n)) <=3D ((sz)) / ((__siz= e)))))) + 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)) = <=3D (sz) / (__size))) && !(((long unsigned int) (__n)) <=3D (sz) / (__size= )))) + return __fread_chk_warn (__ptr, sz, __size, __n, __stream); + return __fread_chk (__ptr, sz, __size, __n, __stream); +} + + +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 __siz= e, 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 buffe= r"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) __attribute__ ((__access__ (__write_only__, 1, 2))) char * +fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) +{ + size_t sz =3D __builtin_object_size (__s, 2 > 1); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((sizeof (char))))) && (((long unsigned int) (__n)) <=3D ((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)) = <=3D (sz) / (sizeof (char)))) && !(((long unsigned int) (__n)) <=3D (sz) / = (sizeof (char))))) + return __fgets_unlocked_chk_warn (__s, sz, __n, __stream); + return __fgets_unlocked_chk (__s, sz, __n, __stream); +} + + + + +extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __siz= e, 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 destinati= on buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) size_t +fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) +{ + size_t sz =3D __builtin_object_size (__ptr, 0); + if (((__builtin_constant_p (sz) && (sz) =3D=3D (long unsigned int) -1) |= | (((__typeof (__n)) 0 < (__typeof (__n)) -1 || (__builtin_constant_p (__n)= && (__n) > 0)) && __builtin_constant_p ((((long unsigned int) (__n)) <=3D = ((sz)) / ((__size)))) && (((long unsigned int) (__n)) <=3D ((sz)) / ((__siz= e)))))) + { + + if (__builtin_constant_p (__size) + && __builtin_constant_p (__n) + && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2)) + && __size * __n <=3D 8) + { + size_t __cnt =3D __size * __n; + char *__cptr =3D (char *) __ptr; + if (__cnt =3D=3D 0) + return 0; + + for (; __cnt > 0; --__cnt) + { + int __c =3D getc_unlocked (__stream); + if (__c =3D=3D (-1)) + break; + *__cptr++ =3D __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)) = <=3D (sz) / (__size))) && !(((long unsigned int) (__n)) <=3D (sz) / (__size= )))) + return __fread_unlocked_chk_warn (__ptr, sz, __size, __n, __stream); + return __fread_unlocked_chk (__ptr, sz, __size, __n, __stream); + +} +# 907 "/usr/include/stdio.h" 2 3 4 + + +} +# 43 "/usr/include/c++/13/cstdio" 2 3 +# 96 "/usr/include/c++/13/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; +} +# 157 "/usr/include/c++/13/cstdio" 3 +namespace __gnu_cxx +{ +# 175 "/usr/include/c++/13/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; +} +# 46 "/usr/include/c++/13/ext/string_conversions.h" 2 3 +# 1 "/usr/include/c++/13/cerrno" 1 3 +# 39 "/usr/include/c++/13/cerrno" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/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__ ((__cons= t__)); + + + + + + + +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 + + + +} +# 43 "/usr/include/c++/13/cerrno" 2 3 +# 47 "/usr/include/c++/13/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 ())= =3D 0; } + ~_Save_errno() { if ((*__errno_location ()) =3D=3D 0) (*__errno_location = ()) =3D _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 =3D __convf(__str, &__endptr, __base...); + + if (__endptr =3D=3D __str) + std::__throw_invalid_argument(__name); + else if ((*__errno_location ()) =3D=3D 34 + || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{})) + std::__throw_out_of_range(__name); + else + __ret =3D __tmp; + + if (__idx) + *__idx =3D __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 =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __n)); + + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + const int __len =3D __convf(__s, __n, __fmt, __args); + + __builtin_va_end(__args); + + return _String(__s, __s + __len); + } + + +} +# 4109 "/usr/include/c++/13/bits/basic_string.h" 2 3 +# 1 "/usr/include/c++/13/bits/charconv.h" 1 3 +# 33 "/usr/include/c++/13/bits/charconv.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/charconv.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __detail +{ + + + template + constexpr bool __integer_to_chars_is_unsigned + =3D ! __gnu_cxx::__int_traits<_Tp>::__is_signed; + + + + template + constexpr unsigned + __to_chars_len(_Tp __value, int __base =3D 10) noexcept + { + + static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation b= ug"); + + + unsigned __n =3D 1; + const unsigned __b2 =3D __base * __base; + const unsigned __b3 =3D __b2 * __base; + const unsigned long __b4 =3D __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 /=3D __b4; + __n +=3D 4; + } + } + + + + + template + void + __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept + { + + static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation b= ug"); + + + constexpr char __digits[201] =3D + "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + unsigned __pos =3D __len - 1; + while (__val >=3D 100) + { + auto const __num =3D (__val % 100) * 2; + __val /=3D 100; + __first[__pos] =3D __digits[__num + 1]; + __first[__pos - 1] =3D __digits[__num]; + __pos -=3D 2; + } + if (__val >=3D 10) + { + auto const __num =3D __val * 2; + __first[1] =3D __digits[__num + 1]; + __first[0] =3D __digits[__num]; + } + else + __first[0] =3D '0' + __val; + } + +} + +} +# 4110 "/usr/include/c++/13/bits/basic_string.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { + + + + inline int + stoi(const string& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(= ), + __idx, __base); } + + inline long + stol(const string& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const string& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const string& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const string& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const string& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } + + inline double + stod(const string& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const string& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx)= ; } + + + + + [[__nodiscard__]] + inline string + to_string(int __val) + + noexcept + + { + const bool __neg =3D __val < 0; + const unsigned __uval =3D __neg ? (unsigned)~__val + 1u : __val; + const auto __len =3D __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned __val) + + noexcept + + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(long __val) + + + + { + const bool __neg =3D __val < 0; + const unsigned long __uval =3D __neg ? (unsigned long)~__val + 1ul : _= _val; + const auto __len =3D __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned long __val) + + + + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(long long __val) + { + const bool __neg =3D __val < 0; + const unsigned long long __uval + =3D __neg ? (unsigned long long)~__val + 1ull : __val; + const auto __len =3D __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned long long __val) + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + + + + [[__nodiscard__]] + inline string + to_string(float __val) + { + const int __n =3D + __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 =3D + __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 =3D + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%Lf", __val); + } + + + + inline int + stoi(const wstring& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(= ), + __idx, __base); } + + inline long + stol(const wstring& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const wstring& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const wstring& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const wstring& __str, size_t* __idx =3D 0, int __base =3D 10) + { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const wstring& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } + + inline double + stod(const wstring& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const wstring& __str, size_t* __idx =3D 0) + { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx)= ; } + + + + [[__nodiscard__]] + inline wstring + to_wstring(int __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(in= t), + L"%d", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned), + L"%u", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(lo= ng), + L"%ld", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long), + L"%lu", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(long long), + L"%lld", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long long), + L"%llu", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(float __val) + { + const int __n =3D + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + [[__nodiscard__]] + inline wstring + to_wstring(double __val) + { + const int __n =3D + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + [[__nodiscard__]] + inline wstring + to_wstring(long double __val) + { + const int __n =3D + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%Lf", __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 + { }; +# 4439 "/usr/include/c++/13/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 { }; +# 4471 "/usr/include/c++/13/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}; } +# 4501 "/usr/include/c++/13/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 + { }; + } + + + + +} +# 55 "/usr/include/c++/13/string" 2 3 +# 1 "/usr/include/c++/13/bits/basic_string.tcc" 1 3 +# 42 "/usr/include/c++/13/bits/basic_string.tcc" 3 +=20=20=20=20=20=20=20 +# 43 "/usr/include/c++/13/bits/basic_string.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::npos; + + template +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + swap(basic_string& __s) noexcept + { + if (this =3D=3D 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()) + { + 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()) + { + 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 =3D __s._M_allocated_capacity; + 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 =3D _M_allocated_capacity; + if (__s._M_is_local()) + { + 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 =3D _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 =3D length(); + _M_length(__s.length()); + __s._M_length(__tmp_length); + } + + template +=20=20=20 + 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 =3D 2 * __old_capacity; + + if (__capacity > max_size()) + __capacity =3D max_size(); + } + + + + return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1); + } + + + + + + template + template +=20=20=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag) + { + size_type __len =3D 0; + size_type __capacity =3D size_type(_S_local_capacity); + + pointer __p =3D _M_use_local_data(); + + while (__beg !=3D __end && __len < __capacity) + { + __p[__len++] =3D *__beg; + ++__beg; + } + + struct _Guard + { +=20=20 + explicit _Guard(basic_string* __s) : _M_guarded(__s) { } + +=20=20 + ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } + + basic_string* _M_guarded; + } __guard(this); + + while (__beg !=3D __end) + { + if (__len =3D=3D __capacity) + { + + __capacity =3D __len + 1; + pointer __another =3D _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++], *__beg); + ++__beg; + } + + __guard._M_guarded =3D 0; + + _M_set_length(__len); + } + + template + template +=20=20=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::forward_iterator_tag) + { + size_type __dnew =3D 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_use_local_data(); + + + struct _Guard + { +=20=20 + explicit _Guard(basic_string* __s) : _M_guarded(__s) { } + +=20=20 + ~_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 =3D 0; + + _M_set_length(__dnew); + } + + template +=20=20=20 + 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_use_local_data(); + + if (__n) + this->_S_assign(_M_data(), __n, __c); + + _M_set_length(__n); + } + + template +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_assign(const basic_string& __str) + { + if (this !=3D std::__addressof(__str)) + { + const size_type __rsize =3D __str.length(); + const size_type __capacity =3D capacity(); + + if (__rsize > __capacity) + { + size_type __new_capacity =3D __rsize; + pointer __tmp =3D _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 +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve(size_type __res) + { + const size_type __capacity =3D capacity(); + + + + + if (__res <=3D __capacity) + return; + + pointer __tmp =3D _M_create(__res, __capacity); + this->_S_copy(__tmp, _M_data(), length() + 1); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__res); + } + + template +=20=20=20 + 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 =3D length() - __pos - __len1; + + size_type __new_capacity =3D length() + __len2 - __len1; + pointer __r =3D _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 +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_erase(size_type __pos, size_type __n) + { + const size_type __how_much =3D 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 +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve() + { + if (_M_is_local()) + return; + + const size_type __length =3D length(); + const size_type __capacity =3D _M_allocated_capacity; + + if (__length <=3D size_type(_S_local_capacity)) + { + this->_S_copy(_M_use_local_data(), _M_data(), __length + 1); + _M_destroy(__capacity); + _M_data(_M_local_data()); + } +# 391 "/usr/include/c++/13/bits/basic_string.tcc" 3 + } + + template +=20=20=20 + void + basic_string<_CharT, _Traits, _Alloc>:: + resize(size_type __n, _CharT __c) + { + const size_type __size =3D this->size(); + if (__size < __n) + this->append(__n - __size, __c); + else if (__n < __size) + this->_M_set_length(__n); + } + + template +=20=20=20 + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_append(const _CharT* __s, size_type __n) + { + const size_type __len =3D __n + this->size(); + + if (__len <=3D 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 +=20=20=20=20=20 + 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 =3D __i2 - __i1; + return _M_replace(__i1 - begin(), __n1, __s._M_data(), + __s.size()); + } + + template +=20=20=20 + 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 =3D this->size(); + const size_type __new_size =3D __old_size + __n2 - __n1; + + if (__new_size <=3D this->capacity()) + { + pointer __p =3D this->_M_data() + __pos1; + + const size_type __how_much =3D __old_size - __pos1 - __n1; + if (__how_much && __n1 !=3D __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 <=3D __len1) + this->_S_move(__p, __s, __len2); + if (__how_much && __len1 !=3D __len2) + this->_S_move(__p + __len2, __p + __len1, __how_much); + if (__len2 > __len1) + { + if (__s + __len2 <=3D __p + __len1) + this->_S_move(__p, __s, __len2); + else if (__s >=3D __p + __len1) + { + + + const size_type __poff =3D (__s - __p) + (__len2 - __len1); + this->_S_copy(__p, __p + __poff, __len2); + } + else + { + const size_type __nleft =3D (__p + __len1) - __s; + this->_S_move(__p, __s, __nleft); + this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); + } + } + } + + template +=20=20=20 + 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 =3D this->size(); + const size_type __new_size =3D __old_size + __len2 - __len1; + + if (__new_size <=3D this->capacity()) + { + pointer __p =3D this->_M_data() + __pos; + + const size_type __how_much =3D __old_size - __pos - __len1; +# 534 "/usr/include/c++/13/bits/basic_string.tcc" 3 + if (__builtin_expect(_M_disjunct(__s), true)) + { + if (__how_much && __len1 !=3D __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 +=20=20=20 + 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 =3D _M_limit(__pos, __n); + ; + if (__n) + _S_copy(__s, _M_data() + __pos, __n); + + return __n; + } +# 611 "/usr/include/c++/13/bits/basic_string.tcc" 3 + template +=20=20=20 + 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 =3D this->size(); + + if (__n =3D=3D 0) + return __pos <=3D __size ? __pos : npos; + if (__pos >=3D __size) + return npos; + + const _CharT __elem0 =3D __s[0]; + const _CharT* const __data =3D data(); + const _CharT* __first =3D __data + __pos; + const _CharT* const __last =3D __data + __size; + size_type __len =3D __size - __pos; + + while (__len >=3D __n) + { + + __first =3D traits_type::find(__first, __len - __n + 1, __elem0); + if (!__first) + return npos; + + + + if (traits_type::compare(__first, __s, __n) =3D=3D 0) + return __first - __data; + __len =3D __last - ++__first; + } + return npos; + } + + template +=20=20=20 + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(_CharT __c, size_type __pos) const noexcept + { + size_type __ret =3D npos; + const size_type __size =3D this->size(); + if (__pos < __size) + { + const _CharT* __data =3D _M_data(); + const size_type __n =3D __size - __pos; + const _CharT* __p =3D traits_type::find(__data + __pos, __n, __c); + if (__p) + __ret =3D __p - __data; + } + return __ret; + } + + template +=20=20=20 + 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 =3D this->size(); + if (__n <=3D __size) + { + __pos =3D std::min(size_type(__size - __n), __pos); + const _CharT* __data =3D _M_data(); + do + { + if (traits_type::compare(__data + __pos, __s, __n) =3D=3D 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template +=20=20=20 + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(_CharT __c, size_type __pos) const noexcept + { + size_type __size =3D this->size(); + if (__size) + { + if (--__size > __pos) + __size =3D __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(_M_data()[__size], __c)) + return __size; + } + return npos; + } + + template +=20=20=20 + 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 =3D traits_type::find(__s, __n, _M_data()[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template +=20=20=20 + 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 =3D this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size =3D __pos; + do + { + if (traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size-- !=3D 0); + } + return npos; + } + + template +=20=20=20 + 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) c= onst + noexcept + { + ; + for (; __pos < this->size(); ++__pos) + if (!traits_type::find(__s, __n, _M_data()[__pos])) + return __pos; + return npos; + } + + template +=20=20=20 + 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 +=20=20=20 + 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) co= nst + noexcept + { + ; + size_type __size =3D this->size(); + if (__size) + { + if (--__size > __pos) + __size =3D __pos; + do + { + if (!traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template +=20=20=20 + 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 =3D this->size(); + if (__size) + { + if (--__size > __pos) + __size =3D __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 =3D 0; + typename __ios_base::iostate __err =3D __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + if (true) + { + + __str.erase(); + _CharT __buf[128]; + __size_type __len =3D 0; + const streamsize __w =3D __in.width(); + const __size_type __n =3D __w > 0 ? static_cast<__size_type>(__w) + : __str.max_size(); + const __ctype_type& __ct =3D use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof =3D _Traits::eof(); + __int_type __c =3D __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(__ctype_base::space, + _Traits::to_char_type(__c))) + { + if (__len =3D=3D sizeof(__buf) / sizeof(_CharT)) + { + __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); + __len =3D 0; + } + __buf[__len++] =3D _Traits::to_char_type(__c); + ++__extracted; + __c =3D __in.rdbuf()->snextc(); + } + __str.append(__buf, __len); + + if (__extracted < __n && _Traits::eq_int_type(__c, __eof)) + __err |=3D __ios_base::eofbit; + __in.width(0); + } + if (false) + { + __in._M_setstate(__ios_base::badbit); + ; + } + if (false) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + + if (!__extracted) + __err |=3D __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 =3D 0; + const __size_type __n =3D __str.max_size(); + typename __ios_base::iostate __err =3D __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, true); + if (__cerb) + { + if (true) + { + __str.erase(); + const __int_type __idelim =3D _Traits::to_int_type(__delim); + const __int_type __eof =3D _Traits::eof(); + __int_type __c =3D __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !_Traits::eq_int_type(__c, __idelim)) + { + __str +=3D _Traits::to_char_type(__c); + ++__extracted; + __c =3D __in.rdbuf()->snextc(); + } + + if (_Traits::eq_int_type(__c, __eof)) + __err |=3D __ios_base::eofbit; + else if (_Traits::eq_int_type(__c, __idelim)) + { + ++__extracted; + __in.rdbuf()->sbumpc(); + } + else + __err |=3D __ios_base::failbit; + } + if (false) + { + __in._M_setstate(__ios_base::badbit); + ; + } + if (false) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + if (!__extracted) + __err |=3D __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } +# 965 "/usr/include/c++/13/bits/basic_string.tcc" 3 + extern template class basic_string; +# 978 "/usr/include/c++/13/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; +# 1004 "/usr/include/c++/13/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&); + + + + +} +# 56 "/usr/include/c++/13/string" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr { + template> + using basic_string =3D std::basic_string<_CharT, _Traits, + polymorphic_allocator<_CharT>>; + using string =3D basic_string; + + + + using u16string =3D basic_string; + using u32string =3D basic_string; + using wstring =3D basic_string; + } + +} +# 25 "/home/malat/highway-1.0.4~git20230317.8681eb8/hwy/tests/hwy_gtest.h"= 2 + + +# 1 "/usr/include/gtest/gtest.h" 1 3 4 +# 55 "/usr/include/gtest/gtest.h" 3 4 +# 1 "/usr/include/c++/13/ostream" 1 3 4 +# 36 "/usr/include/c++/13/ostream" 3 4 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/ostream" 3 + + + +# 1 "/usr/include/c++/13/ios" 1 3 +# 36 "/usr/include/c++/13/ios" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/ios" 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/ios_base.h" 1 3 +# 37 "/usr/include/c++/13/bits/ios_base.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/ios_base.h" 3 + + + +# 1 "/usr/include/c++/13/bits/locale_classes.h" 1 3 +# 37 "/usr/include/c++/13/bits/locale_classes.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/locale_classes.h" 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 62 "/usr/include/c++/13/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; +# 102 "/usr/include/c++/13/bits/locale_classes.h" 3 + static const category none =3D 0; + static const category ctype =3D 1L << 0; + static const category numeric =3D 1L << 1; + static const category collate =3D 1L << 2; + static const category time =3D 1L << 3; + static const category monetary =3D 1L << 4; + static const category messages =3D 1L << 5; + static const category all =3D (ctype | numeric | collate | + time | monetary | messages); +# 121 "/usr/include/c++/13/bits/locale_classes.h" 3 + locale() throw(); +# 130 "/usr/include/c++/13/bits/locale_classes.h" 3 + locale(const locale& __other) throw(); +# 140 "/usr/include/c++/13/bits/locale_classes.h" 3 + explicit + locale(const char* __s); +# 155 "/usr/include/c++/13/bits/locale_classes.h" 3 + locale(const locale& __base, const char* __s, category __cat); +# 166 "/usr/include/c++/13/bits/locale_classes.h" 3 + explicit + locale(const std::string& __s) : locale(__s.c_str()) { } +# 181 "/usr/include/c++/13/bits/locale_classes.h" 3 + locale(const locale& __base, const std::string& __s, category __cat) + : locale(__base, __s.c_str(), __cat) { } +# 196 "/usr/include/c++/13/bits/locale_classes.h" 3 + locale(const locale& __base, const locale& __add, category __cat); +# 209 "/usr/include/c++/13/bits/locale_classes.h" 3 + template + locale(const locale& __other, _Facet* __f); + + + ~locale() throw(); +# 223 "/usr/include/c++/13/bits/locale_classes.h" 3 + const locale& + operator=3D(const locale& __other) throw(); +# 238 "/usr/include/c++/13/bits/locale_classes.h" 3 + template + locale + combine(const locale& __other) const; + + + + + + + __attribute ((__abi_tag__ ("cxx11"))) + string + name() const; +# 258 "/usr/include/c++/13/bits/locale_classes.h" 3 + bool + operator=3D=3D(const locale& __other) const throw(); +# 268 "/usr/include/c++/13/bits/locale_classes.h" 3 + bool + operator!=3D(const locale& __other) const throw() + { return !(this->operator=3D=3D(__other)); } +# 288 "/usr/include/c++/13/bits/locale_classes.h" 3 + template + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; +# 304 "/usr/include/c++/13/bits/locale_classes.h" 3 + static locale + global(const locale& __loc); + + + + + static const locale& + classic(); + + private: + + _Impl* _M_impl; + + + static _Impl* _S_classic; + + + static _Impl* _S_global; + + + + + + static const char* const* const _S_categories; +# 339 "/usr/include/c++/13/bits/locale_classes.h" 3 + enum { _S_categories_size =3D 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[]; + + }; +# 377 "/usr/include/c++/13/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: +# 408 "/usr/include/c++/13/bits/locale_classes.h" 3 + explicit + facet(size_t __refs =3D 0) throw() : _M_refcount(__refs ? 1 : 0) + { } + + + virtual + ~facet(); + + static void + _S_create_c_locale(__c_locale& __cloc, const char* __s, + __c_locale __old =3D 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(); +# 444 "/usr/include/c++/13/bits/locale_classes.h" 3 + facet(const facet&) =3D delete; + + facet& + operator=3D(const facet&) =3D 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) =3D=3D = 1) + { + ; + if (true) + { delete this; } + if (false) + { } + } + } + + const facet* _M_sso_shim(const id*) const; + const facet* _M_cow_shim(const id*) const; + + protected: + class __shim; + }; +# 489 "/usr/include/c++/13/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=3D(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) =3D=3D = 1) + { + ; + if (true) + { delete this; } + if (false) + { } + } + } + + _Impl(const _Impl&, size_t); + _Impl(const char*, size_t); + _Impl(size_t) throw(); + + ~_Impl() throw(); + + _Impl(const _Impl&); + + void + operator=3D(const _Impl&); + + bool + _M_check_same_name() + { + bool __ret =3D true; + if (_M_names[1]) + + for (size_t __i =3D 0; __ret && __i < _S_categories_size - 1; ++__i) + __ret =3D __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) =3D=3D 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()] =3D __facet; + } + + void + _M_install_cache(const facet*, size_t); + + void _M_init_extra(facet**); + void _M_init_extra(void*, void*, const char*, const char*); + + + + + }; +# 659 "/usr/include/c++/13/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; +# 686 "/usr/include/c++/13/bits/locale_classes.h" 3 + explicit + collate(size_t __refs =3D 0) + : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) + { } +# 700 "/usr/include/c++/13/bits/locale_classes.h" 3 + explicit + collate(__c_locale __cloc, size_t __refs =3D 0) + : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) + { } +# 717 "/usr/include/c++/13/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); } +# 736 "/usr/include/c++/13/bits/locale_classes.h" 3 + string_type + transform(const _CharT* __lo, const _CharT* __hi) const + { return this->do_transform(__lo, __hi); } +# 750 "/usr/include/c++/13/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); } +# 779 "/usr/include/c++/13/bits/locale_classes.h" 3 + virtual int + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const; +# 793 "/usr/include/c++/13/bits/locale_classes.h" 3 + virtual string_type + do_transform(const _CharT* __lo, const _CharT* __hi) const; +# 806 "/usr/include/c++/13/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 thr= ow(); + + 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 =3D 0) + : collate<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") !=3D 0 + && __builtin_strcmp(__s, "POSIX") !=3D 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 =3D 0) + : collate_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~collate_byname() { } + }; + + +} + +# 1 "/usr/include/c++/13/bits/locale_classes.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/locale_classes.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/locale_classes.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + locale:: + locale(const locale& __other, _Facet* __f) + { + _M_impl =3D new _Impl(*__other._M_impl, 1); + + if (true) + { _M_impl->_M_install_facet(&_Facet::id, __f); } + if (false) + { + _M_impl->_M_remove_reference(); + ; + } + delete [] _M_impl->_M_names[0]; + _M_impl->_M_names[0] =3D 0; + } + + template + locale + locale:: + combine(const locale& __other) const + { + _Impl* __tmp =3D new _Impl(*_M_impl, 1); + if (true) + { + __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); + } + if (false) + { + __tmp->_M_remove_reference(); + ; + } + 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 =3D use_facet<__collate_type>(*this); + return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), + __s2.data(), __s2.data() + __s2.length()) < 0); + } + + template + inline const _Facet* + __try_use_facet(const locale& __loc) noexcept + { + const size_t __i =3D _Facet::id._M_id(); + const locale::facet** __facets =3D __loc._M_impl->_M_facets; + + + + + + + + if constexpr (__is_same(_Facet, ctype)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt)) ret= urn static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, collate)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_cas= t(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return stat= ic_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_get)) return static_cast= (__facets[__i]); + if constexpr (__is_same(_Facet, money_put)) return static_cast= (__facets[__i]); + if constexpr (__is_same(_Facet, numpunct)) return static_cast<= const _Facet*>(__facets[__i]); + if constexpr (__is_same(_Facet, time_get)) return static_cast<= const _Facet*>(__facets[__i]); + if constexpr (__is_same(_Facet, time_put)) return static_cast<= const _Facet*>(__facets[__i]); + if constexpr (__is_same(_Facet, messages)) return static_cast<= const _Facet*>(__facets[__i]); + + + if constexpr (__is_same(_Facet, ctype)) return static_cast<= const _Facet*>(__facets[__i]); + if constexpr (__is_same(_Facet, num_get)) return static_cas= t(__facets[__i]); + if constexpr (__is_same(_Facet, num_put)) return static_cas= t(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt)) = return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, collate)) return static_cas= t(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_= cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return s= tatic_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_get)) return static_c= ast(__facets[__i]); + if constexpr (__is_same(_Facet, money_put)) return static_c= ast(__facets[__i]); + if constexpr (__is_same(_Facet, numpunct)) return static_ca= st(__facets[__i]); + if constexpr (__is_same(_Facet, time_get)) return static_ca= st(__facets[__i]); + if constexpr (__is_same(_Facet, time_put)) return static_ca= st(__facets[__i]); + if constexpr (__is_same(_Facet, messages)) return static_ca= st(__facets[__i]); + + + + + + if constexpr (__is_same(_Facet, codecvt))= return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt))= return static_cast(__facets[__i]); + + + + + if (__i >=3D __loc._M_impl->_M_facets_size || !__facets[__i]) + return 0; + + + return dynamic_cast(__facets[__i]); + + + + } +# 164 "/usr/include/c++/13/bits/locale_classes.tcc" 3 + template + inline bool + has_facet(const locale& __loc) throw() + { + + static_assert(__is_base_of(locale::facet, _Facet), + "template argument must be derived from locale::facet"); + + + + return std::__try_use_facet<_Facet>(__loc) !=3D 0; + } +# 191 "/usr/include/c++/13/bits/locale_classes.tcc" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdangling-reference" + template + 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 =3D 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 th= row () + { 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 =3D __one.c_str(); + const _CharT* __pend =3D __one.data() + __one.length(); + const _CharT* __q =3D __two.c_str(); + const _CharT* __qend =3D __two.data() + __two.length(); + + + + + for (;;) + { + const int __res =3D _M_compare(__p, __q); + if (__res) + return __res; + + __p +=3D char_traits<_CharT>::length(__p); + __q +=3D char_traits<_CharT>::length(__q); + if (__p =3D=3D __pend && __q =3D=3D __qend) + return 0; + else if (__p =3D=3D __pend) + return -1; + else if (__q =3D=3D __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 =3D __str.c_str(); + const _CharT* __pend =3D __str.data() + __str.length(); + + size_t __len =3D (__hi - __lo) * 2; + + _CharT* __c =3D new _CharT[__len]; + + if (true) + { + + + + for (;;) + { + + size_t __res =3D _M_transform(__c, __p, __len); + + + if (__res >=3D __len) + { + __len =3D __res + 1; + delete [] __c, __c =3D 0; + __c =3D new _CharT[__len]; + __res =3D _M_transform(__c, __p, __len); + } + + __ret.append(__c, __res); + __p +=3D char_traits<_CharT>::length(__p); + if (__p =3D=3D __pend) + break; + + __p++; + __ret.push_back(_CharT()); + } + } + if (false) + { + delete [] __c; + ; + } + + delete [] __c; + + return __ret; + } + + template + long + collate<_CharT>:: + do_hash(const _CharT* __lo, const _CharT* __hi) const + { + unsigned long __val =3D 0; + for (; __lo < __hi; ++__lo) + __val =3D + *__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&); + + + + +} +# 870 "/usr/include/c++/13/bits/locale_classes.h" 2 3 +# 42 "/usr/include/c++/13/bits/ios_base.h" 2 3 + + + + +# 1 "/usr/include/c++/13/system_error" 1 3 +# 32 "/usr/include/c++/13/system_error" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/system_error" 3 +# 41 "/usr/include/c++/13/system_error" 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/error_constants.h" 1 3 +# 34 "/usr/include/riscv64-linux-gnu/c++/13/bits/error_constants.h" 3 +# 1 "/usr/include/c++/13/cerrno" 1 3 +# 39 "/usr/include/c++/13/cerrno" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cerrno" 3 +# 35 "/usr/include/riscv64-linux-gnu/c++/13/bits/error_constants.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + enum class errc + { + address_family_not_supported =3D 97, + address_in_use =3D 98, + address_not_available =3D 99, + already_connected =3D 106, + argument_list_too_long =3D 7, + argument_out_of_domain =3D 33, + bad_address =3D 14, + bad_file_descriptor =3D 9, + + + bad_message =3D 74, + + + broken_pipe =3D 32, + connection_aborted =3D 103, + connection_already_in_progress =3D 114, + connection_refused =3D 111, + connection_reset =3D 104, + cross_device_link =3D 18, + destination_address_required =3D 89, + device_or_resource_busy =3D 16, + directory_not_empty =3D 39, + executable_format_error =3D 8, + file_exists =3D 17, + file_too_large =3D 27, + filename_too_long =3D 36, + function_not_supported =3D 38, + host_unreachable =3D 113, + + + identifier_removed =3D 43, + + + illegal_byte_sequence =3D 84, + inappropriate_io_control_operation =3D 25, + interrupted =3D 4, + invalid_argument =3D 22, + invalid_seek =3D 29, + io_error =3D 5, + is_a_directory =3D 21, + message_size =3D 90, + network_down =3D 100, + network_reset =3D 102, + network_unreachable =3D 101, + no_buffer_space =3D 105, + no_child_process =3D 10, + + + no_link =3D 67, + + + no_lock_available =3D 37, + + + no_message_available =3D 61, + + + no_message =3D 42, + no_protocol_option =3D 92, + no_space_on_device =3D 28, + + + no_stream_resources =3D 63, + + + no_such_device_or_address =3D 6, + no_such_device =3D 19, + no_such_file_or_directory =3D 2, + no_such_process =3D 3, + not_a_directory =3D 20, + not_a_socket =3D 88, + + + not_a_stream =3D 60, + + + not_connected =3D 107, + not_enough_memory =3D 12, + + + not_supported =3D 95, + + + + operation_canceled =3D 125, + + + operation_in_progress =3D 115, + operation_not_permitted =3D 1, + operation_not_supported =3D 95, + operation_would_block =3D 11, + + + owner_dead =3D 130, + + + permission_denied =3D 13, + + + protocol_error =3D 71, + + + protocol_not_supported =3D 93, + read_only_file_system =3D 30, + resource_deadlock_would_occur =3D 35, + resource_unavailable_try_again =3D 11, + result_out_of_range =3D 34, + + + state_not_recoverable =3D 131, + + + + stream_timeout =3D 62, + + + + text_file_busy =3D 26, + + + timed_out =3D 110, + too_many_files_open_in_system =3D 23, + too_many_files_open =3D 24, + too_many_links =3D 31, + too_many_symbolic_link_levels =3D 40, + + + value_too_large =3D 75, + + + + + wrong_protocol_type =3D 91 + }; + + +} +# 42 "/usr/include/c++/13/system_error" 2 3 + +# 1 "/usr/include/c++/13/stdexcept" 1 3 +# 36 "/usr/include/c++/13/stdexcept" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/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=3D(const __cow_string&) noexcept; + ~__cow_string(); + + __cow_string(__cow_string&&) noexcept; + __cow_string& operator=3D(__cow_string&&) noexcept; + + }; + + typedef basic_string __sso_string; +# 113 "/usr/include/c++/13/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=3D(logic_error&&) noexcept; + + + + logic_error(const logic_error&) noexcept; + logic_error& operator=3D(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&) =3D default; + domain_error& operator=3D(const domain_error&) =3D default; + domain_error(domain_error&&) =3D default; + domain_error& operator=3D(domain_error&&) =3D 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&) =3D default; + invalid_argument& operator=3D(const invalid_argument&) =3D default; + invalid_argument(invalid_argument&&) =3D default; + invalid_argument& operator=3D(invalid_argument&&) =3D 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&) =3D default; + length_error& operator=3D(const length_error&) =3D default; + length_error(length_error&&) =3D default; + length_error& operator=3D(length_error&&) =3D 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&) =3D default; + out_of_range& operator=3D(const out_of_range&) =3D default; + out_of_range(out_of_range&&) =3D default; + out_of_range& operator=3D(out_of_range&&) =3D 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=3D(runtime_error&&) noexcept; + + + + runtime_error(const runtime_error&) noexcept; + runtime_error& operator=3D(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&) =3D default; + range_error& operator=3D(const range_error&) =3D default; + range_error(range_error&&) =3D default; + range_error& operator=3D(range_error&&) =3D 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&) =3D default; + overflow_error& operator=3D(const overflow_error&) =3D default; + overflow_error(overflow_error&&) =3D default; + overflow_error& operator=3D(overflow_error&&) =3D 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&) =3D default; + underflow_error& operator=3D(const underflow_error&) =3D default; + underflow_error(underflow_error&&) =3D default; + underflow_error& operator=3D(underflow_error&&) =3D default; + + virtual ~underflow_error() noexcept; + }; + + + + +} +# 44 "/usr/include/c++/13/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 =3D + is_error_code_enum<_Tp>::value; + template + inline constexpr bool is_error_condition_enum_v =3D + is_error_condition_enum<_Tp>::value; + + + +inline namespace _V2 { +# 106 "/usr/include/c++/13/system_error" 3 + class error_category + { + public: + constexpr error_category() noexcept =3D default; + + virtual ~error_category(); + + error_category(const error_category&) =3D delete; + error_category& operator=3D(const error_category&) =3D delete; + + + virtual const char* + name() const noexcept =3D 0; + + + + + + + private: + __attribute ((__abi_tag__ ("cxx11"))) + virtual __cow_string + _M_message(int) const; + + public: + + __attribute ((__abi_tag__ ("cxx11"))) + virtual string + message(int) const =3D 0; +# 144 "/usr/include/c++/13/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=3D=3D(const error_category& __other) const noexcept + { return this =3D=3D &__other; } +# 170 "/usr/include/c++/13/system_error" 3 + bool + operator<(const error_category& __other) const noexcept + { return less()(this, &__other); } + + bool + operator!=3D(const error_category& __other) const noexcept + { return this !=3D &__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() =3D delete; + void make_error_condition() =3D delete; +} +# 223 "/usr/include/c++/13/system_error" 3 + class error_code + { + template + using _Check + =3D __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 =3D make_error_code(__e); + } + + error_code(const error_code&) =3D default; + error_code& operator=3D(const error_code&) =3D default; + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value =3D __v; + _M_cat =3D &__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 !=3D 0; } + + + private: + int _M_value; + const error_category* _M_cat; + }; +# 300 "/usr/include/c++/13/system_error" 3 + [[__nodiscard__]] + inline error_code + make_error_code(errc __e) noexcept + { return error_code(static_cast(__e), generic_category()); } +# 323 "/usr/include/c++/13/system_error" 3 + inline bool + operator<(const error_code& __lhs, const error_code& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() =3D=3D __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()); } +# 354 "/usr/include/c++/13/system_error" 3 + class error_condition + { + template + using _Check + =3D __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 =3D make_error_condition(__e); + } + + error_condition(const error_condition&) =3D default; + error_condition& operator=3D(const error_condition&) =3D default; + + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value =3D __v; + _M_cat =3D &__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 !=3D 0; } + + + private: + int _M_value; + const error_category* _M_cat; + }; +# 433 "/usr/include/c++/13/system_error" 3 + [[__nodiscard__]] + inline error_condition + make_error_condition(errc __e) noexcept + { return error_condition(static_cast(__e), generic_category()); } +# 447 "/usr/include/c++/13/system_error" 3 + [[__nodiscard__]] + inline bool + operator=3D=3D(const error_code& __lhs, const error_code& __rhs) noexcept + { + return __lhs.category() =3D=3D __rhs.category() + && __lhs.value() =3D=3D __rhs.value(); + } +# 463 "/usr/include/c++/13/system_error" 3 + [[__nodiscard__]] + inline bool + operator=3D=3D(const error_code& __lhs, const error_condition& __rhs) no= except + { + return __lhs.category().equivalent(__lhs.value(), __rhs) + || __rhs.category().equivalent(__lhs, __rhs.value()); + } +# 478 "/usr/include/c++/13/system_error" 3 + [[__nodiscard__]] + inline bool + operator=3D=3D(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return __lhs.category() =3D=3D __rhs.category() + && __lhs.value() =3D=3D __rhs.value(); + } +# 506 "/usr/include/c++/13/system_error" 3 + inline bool + operator<(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() =3D=3D __rhs.category() + && __lhs.value() < __rhs.value())); + } + + + inline bool + operator=3D=3D(const error_condition& __lhs, const error_code& __rhs) no= except + { + return (__rhs.category().equivalent(__rhs.value(), __lhs) + || __lhs.category().equivalent(__rhs, __lhs.value())); + } + + + inline bool + operator!=3D(const error_code& __lhs, const error_code& __rhs) noexcept + { return !(__lhs =3D=3D __rhs); } + + + inline bool + operator!=3D(const error_code& __lhs, const error_condition& __rhs) noex= cept + { return !(__lhs =3D=3D __rhs); } + + + inline bool + operator!=3D(const error_condition& __lhs, const error_code& __rhs) noex= cept + { return !(__lhs =3D=3D __rhs); } + + + inline bool + operator!=3D(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { return !(__lhs =3D=3D __rhs); } +# 556 "/usr/include/c++/13/system_error" 3 + class system_error : public std::runtime_error + { + private: + error_code _M_code; + + public: + system_error(error_code __ec =3D 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& __wh= at) + : runtime_error(__what + ": " + error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + + system_error (const system_error &) =3D default; + system_error &operator=3D (const system_error &) =3D 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 =3D 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 =3D std::_Hash_impl::hash(__e.value()); + return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); + } + }; + + + +} +# 47 "/usr/include/c++/13/bits/ios_base.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + enum _Ios_Fmtflags + { + _S_boolalpha =3D 1L << 0, + _S_dec =3D 1L << 1, + _S_fixed =3D 1L << 2, + _S_hex =3D 1L << 3, + _S_internal =3D 1L << 4, + _S_left =3D 1L << 5, + _S_oct =3D 1L << 6, + _S_right =3D 1L << 7, + _S_scientific =3D 1L << 8, + _S_showbase =3D 1L << 9, + _S_showpoint =3D 1L << 10, + _S_showpos =3D 1L << 11, + _S_skipws =3D 1L << 12, + _S_unitbuf =3D 1L << 13, + _S_uppercase =3D 1L << 14, + _S_adjustfield =3D _S_left | _S_right | _S_internal, + _S_basefield =3D _S_dec | _S_oct | _S_hex, + _S_floatfield =3D _S_scientific | _S_fixed, + _S_ios_fmtflags_end =3D 1L << 16, + _S_ios_fmtflags_max =3D 0x7fffffff, + _S_ios_fmtflags_min =3D ~0x7fffffff + }; + + inline constexpr _Ios_Fmtflags + operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator~(_Ios_Fmtflags __a) + { return _Ios_Fmtflags(~static_cast(__a)); } + + inline const _Ios_Fmtflags& + operator|=3D(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a =3D __a | __b; } + + inline const _Ios_Fmtflags& + operator&=3D(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a =3D __a & __b; } + + inline const _Ios_Fmtflags& + operator^=3D(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a =3D __a ^ __b; } + + + enum _Ios_Openmode + { + _S_app =3D 1L << 0, + _S_ate =3D 1L << 1, + _S_bin =3D 1L << 2, + _S_in =3D 1L << 3, + _S_out =3D 1L << 4, + _S_trunc =3D 1L << 5, + _S_noreplace =3D 1L << 6, + _S_ios_openmode_end =3D 1L << 16, + _S_ios_openmode_max =3D 0x7fffffff, + _S_ios_openmode_min =3D ~0x7fffffff + }; + + inline constexpr _Ios_Openmode + operator&(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator|(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator^(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator~(_Ios_Openmode __a) + { return _Ios_Openmode(~static_cast(__a)); } + + inline const _Ios_Openmode& + operator|=3D(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a =3D __a | __b; } + + inline const _Ios_Openmode& + operator&=3D(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a =3D __a & __b; } + + inline const _Ios_Openmode& + operator^=3D(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a =3D __a ^ __b; } + + + enum _Ios_Iostate + { + _S_goodbit =3D 0, + _S_badbit =3D 1L << 0, + _S_eofbit =3D 1L << 1, + _S_failbit =3D 1L << 2, + _S_ios_iostate_end =3D 1L << 16, + _S_ios_iostate_max =3D 0x7fffffff, + _S_ios_iostate_min =3D ~0x7fffffff + }; + + inline constexpr _Ios_Iostate + operator&(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator|(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator^(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator~(_Ios_Iostate __a) + { return _Ios_Iostate(~static_cast(__a)); } + + inline const _Ios_Iostate& + operator|=3D(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a =3D __a | __b; } + + inline const _Ios_Iostate& + operator&=3D(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a =3D __a & __b; } + + inline const _Ios_Iostate& + operator^=3D(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a =3D __a ^ __b; } + + + enum _Ios_Seekdir + { + _S_beg =3D 0, + _S_cur =3D 1, + _S_end =3D 2, + _S_ios_seekdir_end =3D 1L << 16 + }; + + + + enum class io_errc { stream =3D 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()); } +# 233 "/usr/include/c++/13/bits/ios_base.h" 3 + class ios_base + { +# 251 "/usr/include/c++/13/bits/ios_base.h" 3 + public: +# 260 "/usr/include/c++/13/bits/ios_base.h" 3 + class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_er= ror + { + public: + explicit + failure(const string& __str); + + + explicit + failure(const string&, const error_code&); + + explicit + failure(const char*, const error_code& =3D io_errc::stream); + + + virtual + ~failure() throw(); + + virtual const char* + what() const throw(); + }; +# 346 "/usr/include/c++/13/bits/ios_base.h" 3 + typedef _Ios_Fmtflags fmtflags; + + + static const fmtflags boolalpha =3D _S_boolalpha; + + + static const fmtflags dec =3D _S_dec; + + + static const fmtflags fixed =3D _S_fixed; + + + static const fmtflags hex =3D _S_hex; + + + + + static const fmtflags internal =3D _S_internal; + + + + static const fmtflags left =3D _S_left; + + + static const fmtflags oct =3D _S_oct; + + + + static const fmtflags right =3D _S_right; + + + static const fmtflags scientific =3D _S_scientific; + + + + static const fmtflags showbase =3D _S_showbase; + + + + static const fmtflags showpoint =3D _S_showpoint; + + + static const fmtflags showpos =3D _S_showpos; + + + static const fmtflags skipws =3D _S_skipws; + + + static const fmtflags unitbuf =3D _S_unitbuf; + + + + static const fmtflags uppercase =3D _S_uppercase; + + + static const fmtflags adjustfield =3D _S_adjustfield; + + + static const fmtflags basefield =3D _S_basefield; + + + static const fmtflags floatfield =3D _S_floatfield; +# 421 "/usr/include/c++/13/bits/ios_base.h" 3 + typedef _Ios_Iostate iostate; + + + + static const iostate badbit =3D _S_badbit; + + + static const iostate eofbit =3D _S_eofbit; + + + + + static const iostate failbit =3D _S_failbit; + + + static const iostate goodbit =3D _S_goodbit; +# 452 "/usr/include/c++/13/bits/ios_base.h" 3 + typedef _Ios_Openmode openmode; + + + static const openmode app =3D _S_app; + + + static const openmode ate =3D _S_ate; + + + + + static const openmode binary =3D _S_bin; + + + static const openmode in =3D _S_in; + + + static const openmode out =3D _S_out; + + + static const openmode trunc =3D _S_trunc; + + static const openmode __noreplace =3D _S_noreplace; +# 492 "/usr/include/c++/13/bits/ios_base.h" 3 + typedef _Ios_Seekdir seekdir; + + + static const seekdir beg =3D _S_beg; + + + static const seekdir cur =3D _S_cur; + + + static const seekdir end =3D _S_end; +# 525 "/usr/include/c++/13/bits/ios_base.h" 3 + enum event + { + erase_event, + imbue_event, + copyfmt_event + }; +# 542 "/usr/include/c++/13/bits/ios_base.h" 3 + typedef void (*event_callback) (event __e, ios_base& __b, int __i); +# 554 "/usr/include/c++/13/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 =3D __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount,= -1); + if (__res =3D=3D 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 =3D 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&) =3D default; + Init& operator=3D(const Init&) =3D default; + + + private: + static _Atomic_word _S_refcount; + static bool _S_synced_with_stdio; + }; + + + + + + + fmtflags + flags() const + { return _M_flags; } +# 672 "/usr/include/c++/13/bits/ios_base.h" 3 + fmtflags + flags(fmtflags __fmtfl) + { + fmtflags __old =3D _M_flags; + _M_flags =3D __fmtfl; + return __old; + } +# 688 "/usr/include/c++/13/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl) + { + fmtflags __old =3D _M_flags; + _M_flags |=3D __fmtfl; + return __old; + } +# 705 "/usr/include/c++/13/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl, fmtflags __mask) + { + fmtflags __old =3D _M_flags; + _M_flags &=3D ~__mask; + _M_flags |=3D (__fmtfl & __mask); + return __old; + } + + + + + + + + void + unsetf(fmtflags __mask) + { _M_flags &=3D ~__mask; } +# 731 "/usr/include/c++/13/bits/ios_base.h" 3 + streamsize + precision() const + { return _M_precision; } + + + + + + + streamsize + precision(streamsize __prec) + { + streamsize __old =3D _M_precision; + _M_precision =3D __prec; + return __old; + } + + + + + + + + streamsize + width() const + { return _M_width; } + + + + + + + streamsize + width(streamsize __wide) + { + streamsize __old =3D _M_width; + _M_width =3D __wide; + return __old; + } +# 782 "/usr/include/c++/13/bits/ios_base.h" 3 + static bool + sync_with_stdio(bool __sync =3D true); +# 794 "/usr/include/c++/13/bits/ios_base.h" 3 + locale + imbue(const locale& __loc) throw(); +# 805 "/usr/include/c++/13/bits/ios_base.h" 3 + locale + getloc() const + { return _M_ios_locale; } +# 816 "/usr/include/c++/13/bits/ios_base.h" 3 + const locale& + _M_getloc() const + { return _M_ios_locale; } +# 835 "/usr/include/c++/13/bits/ios_base.h" 3 + static int + xalloc() throw(); +# 851 "/usr/include/c++/13/bits/ios_base.h" 3 + long& + iword(int __ix) + { + _Words& __word =3D ((unsigned)__ix < (unsigned)_M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, true); + return __word._M_iword; + } +# 872 "/usr/include/c++/13/bits/ios_base.h" 3 + void*& + pword(int __ix) + { + _Words& __word =3D ((unsigned)__ix < (unsigned)_M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, false); + return __word._M_pword; + } +# 889 "/usr/include/c++/13/bits/ios_base.h" 3 + virtual ~ios_base(); + + protected: + ios_base() throw (); +# 903 "/usr/include/c++/13/bits/ios_base.h" 3 + public: + ios_base(const ios_base&) =3D delete; + + ios_base& + operator=3D(const ios_base&) =3D 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::floatfie= ld); + return __base; + } + + + inline ios_base& + defaultfloat(ios_base& __base) + { + __base.unsetf(ios_base::floatfield); + return __base; + } + + + +} +# 45 "/usr/include/c++/13/ios" 2 3 +# 1 "/usr/include/c++/13/streambuf" 1 3 +# 36 "/usr/include/c++/13/streambuf" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/streambuf" 3 +# 47 "/usr/include/c++/13/streambuf" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, + basic_streambuf<_CharT, _Traits>*, bool&); +# 123 "/usr/include/c++/13/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() + { } +# 215 "/usr/include/c++/13/streambuf" 3 + locale + pubimbue(const locale& __loc) + { + locale __tmp(this->getloc()); + this->imbue(__loc); + _M_buf_locale =3D __loc; + return __tmp; + } +# 232 "/usr/include/c++/13/streambuf" 3 + locale + getloc() const + { return _M_buf_locale; } +# 245 "/usr/include/c++/13/streambuf" 3 + basic_streambuf* + pubsetbuf(char_type* __s, streamsize __n) + { return this->setbuf(__s, __n); } +# 257 "/usr/include/c++/13/streambuf" 3 + pos_type + pubseekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode =3D ios_base::in | ios_base::out) + { return this->seekoff(__off, __way, __mode); } +# 269 "/usr/include/c++/13/streambuf" 3 + pos_type + pubseekpos(pos_type __sp, + ios_base::openmode __mode =3D ios_base::in | ios_base::out) + { return this->seekpos(__sp, __mode); } + + + + + int + pubsync() { return this->sync(); } +# 290 "/usr/include/c++/13/streambuf" 3 + streamsize + in_avail() + { + const streamsize __ret =3D this->egptr() - this->gptr(); + return __ret ? __ret : this->showmanyc(); + } +# 304 "/usr/include/c++/13/streambuf" 3 + int_type + snextc() + { + int_type __ret =3D traits_type::eof(); + if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), + __ret), true)) + __ret =3D this->sgetc(); + return __ret; + } +# 322 "/usr/include/c++/13/streambuf" 3 + int_type + sbumpc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + { + __ret =3D traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + else + __ret =3D this->uflow(); + return __ret; + } +# 344 "/usr/include/c++/13/streambuf" 3 + int_type + sgetc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + __ret =3D traits_type::to_int_type(*this->gptr()); + else + __ret =3D this->underflow(); + return __ret; + } +# 363 "/usr/include/c++/13/streambuf" 3 + streamsize + sgetn(char_type* __s, streamsize __n) + { return this->xsgetn(__s, __n); } +# 378 "/usr/include/c++/13/streambuf" 3 + int_type + sputbackc(char_type __c) + { + int_type __ret; + const bool __testpos =3D this->eback() < this->gptr(); + if (__builtin_expect(!__testpos || + !traits_type::eq(__c, this->gptr()[-1]), false)) + __ret =3D this->pbackfail(traits_type::to_int_type(__c)); + else + { + this->gbump(-1); + __ret =3D traits_type::to_int_type(*this->gptr()); + } + return __ret; + } +# 403 "/usr/include/c++/13/streambuf" 3 + int_type + sungetc() + { + int_type __ret; + if (__builtin_expect(this->eback() < this->gptr(), true)) + { + this->gbump(-1); + __ret =3D traits_type::to_int_type(*this->gptr()); + } + else + __ret =3D this->pbackfail(); + return __ret; + } +# 430 "/usr/include/c++/13/streambuf" 3 + int_type + sputc(char_type __c) + { + int_type __ret; + if (__builtin_expect(this->pptr() < this->epptr(), true)) + { + *this->pptr() =3D __c; + this->pbump(1); + __ret =3D traits_type::to_int_type(__c); + } + else + __ret =3D this->overflow(traits_type::to_int_type(__c)); + return __ret; + } +# 456 "/usr/include/c++/13/streambuf" 3 + streamsize + sputn(const char_type* __s, streamsize __n) + { return this->xsputn(__s, __n); } + + protected: +# 470 "/usr/include/c++/13/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()) + { } +# 488 "/usr/include/c++/13/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; } +# 504 "/usr/include/c++/13/streambuf" 3 + void + gbump(int __n) { _M_in_cur +=3D __n; } +# 515 "/usr/include/c++/13/streambuf" 3 + void + setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) + { + _M_in_beg =3D __gbeg; + _M_in_cur =3D __gnext; + _M_in_end =3D __gend; + } +# 535 "/usr/include/c++/13/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; } +# 551 "/usr/include/c++/13/streambuf" 3 + void + pbump(int __n) { _M_out_cur +=3D __n; } +# 561 "/usr/include/c++/13/streambuf" 3 + void + setp(char_type* __pbeg, char_type* __pend) + { + _M_out_beg =3D _M_out_cur =3D __pbeg; + _M_out_end =3D __pend; + } +# 582 "/usr/include/c++/13/streambuf" 3 + virtual void + imbue(const locale& __loc __attribute__ ((__unused__))) + { } +# 597 "/usr/include/c++/13/streambuf" 3 + virtual basic_streambuf* + setbuf(char_type*, streamsize) + { return this; } +# 608 "/usr/include/c++/13/streambuf" 3 + virtual pos_type + seekoff(off_type, ios_base::seekdir, + ios_base::openmode =3D ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 620 "/usr/include/c++/13/streambuf" 3 + virtual pos_type + seekpos(pos_type, + ios_base::openmode =3D ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 633 "/usr/include/c++/13/streambuf" 3 + virtual int + sync() { return 0; } +# 655 "/usr/include/c++/13/streambuf" 3 + virtual streamsize + showmanyc() { return 0; } +# 671 "/usr/include/c++/13/streambuf" 3 + virtual streamsize + xsgetn(char_type* __s, streamsize __n); +# 693 "/usr/include/c++/13/streambuf" 3 + virtual int_type + underflow() + { return traits_type::eof(); } +# 706 "/usr/include/c++/13/streambuf" 3 + virtual int_type + uflow() + { + int_type __ret =3D traits_type::eof(); + const bool __testeof =3D traits_type::eq_int_type(this->underflow(), + __ret); + if (!__testeof) + { + __ret =3D traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + return __ret; + } +# 730 "/usr/include/c++/13/streambuf" 3 + virtual int_type + pbackfail(int_type __c __attribute__ ((__unused__)) =3D traits_type:= :eof()) + { return traits_type::eof(); } +# 748 "/usr/include/c++/13/streambuf" 3 + virtual streamsize + xsputn(const char_type* __s, streamsize __n); +# 774 "/usr/include/c++/13/streambuf" 3 + virtual int_type + overflow(int_type __c __attribute__ ((__unused__)) =3D traits_type::= eof()) + { return traits_type::eof(); } +# 801 "/usr/include/c++/13/streambuf" 3 + void + __safe_gbump(streamsize __n) { _M_in_cur +=3D __n; } + + void + __safe_pbump(streamsize __n) { _M_out_cur +=3D __n; } + + + + + protected: + + basic_streambuf(const basic_streambuf&); + + basic_streambuf& + operator=3D(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&) =3D default; + + template + std::basic_streambuf<_CharT, _Traits>& + std::basic_streambuf<_CharT, _Traits>:: + operator=3D(const basic_streambuf&) =3D 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++/13/bits/streambuf.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/streambuf.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/streambuf.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsgetn(char_type* __s, streamsize __n) + { + streamsize __ret =3D 0; + while (__ret < __n) + { + const streamsize __buf_len =3D this->egptr() - this->gptr(); + if (__buf_len) + { + const streamsize __remaining =3D __n - __ret; + const streamsize __len =3D std::min(__buf_len, __remaining); + traits_type::copy(__s, this->gptr(), __len); + __ret +=3D __len; + __s +=3D __len; + this->__safe_gbump(__len); + } + + if (__ret < __n) + { + const int_type __c =3D 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 =3D 0; + while (__ret < __n) + { + const streamsize __buf_len =3D this->epptr() - this->pptr(); + if (__buf_len) + { + const streamsize __remaining =3D __n - __ret; + const streamsize __len =3D std::min(__buf_len, __remaining); + traits_type::copy(this->pptr(), __s, __len); + __ret +=3D __len; + __s +=3D __len; + this->__safe_pbump(__len); + } + + if (__ret < __n) + { + int_type __c =3D 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 =3D 0; + __ineof =3D true; + typename _Traits::int_type __c =3D __sbin->sgetc(); + while (!_Traits::eq_int_type(__c, _Traits::eof())) + { + __c =3D __sbout->sputc(_Traits::to_char_type(__c)); + if (_Traits::eq_int_type(__c, _Traits::eof())) + { + __ineof =3D false; + break; + } + ++__ret; + __c =3D __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*); + + + + +} +# 861 "/usr/include/c++/13/streambuf" 2 3 +# 46 "/usr/include/c++/13/ios" 2 3 +# 1 "/usr/include/c++/13/bits/basic_ios.h" 1 3 +# 33 "/usr/include/c++/13/bits/basic_ios.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/basic_ios.h" 3 + + + +# 1 "/usr/include/c++/13/bits/locale_facets.h" 1 3 +# 37 "/usr/include/c++/13/bits/locale_facets.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/locale_facets.h" 3 + +# 1 "/usr/include/c++/13/cwctype" 1 3 +# 39 "/usr/include/c++/13/cwctype" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cwctype" 3 +# 50 "/usr/include/c++/13/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 =3D 0, + __ISwlower =3D 1, + __ISwalpha =3D 2, + __ISwdigit =3D 3, + __ISwxdigit =3D 4, + __ISwspace =3D 5, + __ISwprint =3D 6, + __ISwgraph =3D 7, + __ISwblank =3D 8, + __ISwcntrl =3D 9, + __ISwpunct =3D 10, + __ISwalnum =3D 11, + + _ISwupper =3D ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : = ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 2= 4 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24= )))), + _ISwlower =3D ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : = ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 2= 4 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24= )))), + _ISwalpha =3D ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : = ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 2= 4 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24= )))), + _ISwdigit =3D ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : = ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 2= 4 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24= )))), + _ISwxdigit =3D ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24)= : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigi= t) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit= )) >> 24)))), + _ISwspace =3D ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : = ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 2= 4 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24= )))), + _ISwprint =3D ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : = ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 2= 4 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24= )))), + _ISwgraph =3D ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : = ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 2= 4 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24= )))), + _ISwblank =3D ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : = ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 2= 4 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24= )))), + _ISwcntrl =3D ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : = ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 2= 4 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24= )))), + _ISwpunct =3D ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : = ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 2= 4 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24= )))), + _ISwalnum =3D ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : = ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 2= 4 ? (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); + + + +} +# 51 "/usr/include/c++/13/cwctype" 2 3 +# 80 "/usr/include/c++/13/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; +} +# 40 "/usr/include/c++/13/bits/locale_facets.h" 2 3 +# 1 "/usr/include/c++/13/cctype" 1 3 +# 39 "/usr/include/c++/13/cctype" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cctype" 3 +# 41 "/usr/include/c++/13/bits/locale_facets.h" 2 3 +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/ctype_base.h" 1 3 +# 36 "/usr/include/riscv64-linux-gnu/c++/13/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 =3D _ISupper; + static const mask lower =3D _ISlower; + static const mask alpha =3D _ISalpha; + static const mask digit =3D _ISdigit; + static const mask xdigit =3D _ISxdigit; + static const mask space =3D _ISspace; + static const mask print =3D _ISprint; + static const mask graph =3D _ISalpha | _ISdigit | _ISpunct; + static const mask cntrl =3D _IScntrl; + static const mask punct =3D _ISpunct; + static const mask alnum =3D _ISalpha | _ISdigit; + + static const mask blank =3D _ISblank; + + }; + + +} +# 42 "/usr/include/c++/13/bits/locale_facets.h" 2 3 + + + + + + +# 1 "/usr/include/c++/13/bits/streambuf_iterator.h" 1 3 +# 33 "/usr/include/c++/13/bits/streambuf_iterator.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/streambuf_iterator.h" 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + +=20 +# 49 "/usr/include/c++/13/bits/streambuf_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + class istreambuf_iterator + : public iterator + { + public: +# 70 "/usr/include/c++/13/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 =3D default; + + ~istreambuf_iterator() =3D 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=3D(const istreambuf_iterator&) noexcept =3D default; + + + + + + [[__nodiscard__]] + char_type + operator*() const + { + int_type __c =3D _M_get(); +# 161 "/usr/include/c++/13/bits/streambuf_iterator.h" 3 + return traits_type::to_char_type(__c); + } + + + istreambuf_iterator& + operator++() + { + + + + ; + + _M_sbuf->sbumpc(); + _M_c =3D traits_type::eof(); + return *this; + } + + + istreambuf_iterator + operator++(int) + { + + + + ; + + istreambuf_iterator __old =3D *this; + __old._M_c =3D _M_sbuf->sbumpc(); + _M_c =3D traits_type::eof(); + return __old; + } + + + + + + [[__nodiscard__]] + bool + equal(const istreambuf_iterator& __b) const + { return _M_at_eof() =3D=3D __b._M_at_eof(); } + + private: + int_type + _M_get() const + { + int_type __ret =3D _M_c; + if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret =3D _M_sbuf->sgetc())) + _M_sbuf =3D 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 =3D traits_type::eof(); + return traits_type::eq_int_type(__c, __eof); + } + + + + + + + + }; + + template + [[__nodiscard__]] + inline bool + operator=3D=3D(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return __a.equal(__b); } + + + template + [[__nodiscard__]] + inline bool + operator!=3D(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: +# 284 "/usr/include/c++/13/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=3D(_CharT __c) + { + if (!_M_failed && + _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) + _M_failed =3D 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) !=3D __len, + false)) + _M_failed =3D 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 =3D 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 =3D __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 =3D __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 =3D __first._M_sbuf; + int_type __c =3D __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof())) + { + const streamsize __n =3D __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + traits_type::copy(__result, __sb->gptr(), __n); + __sb->__safe_gbump(__n); + __result +=3D __n; + __c =3D __sb->underflow(); + } + else + { + *__result++ =3D traits_type::to_char_type(__c); + __c =3D __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* __resu= lt, + bool __strict __attribute__((__unused__))) + { + if (__n =3D=3D 0) + return __result; + +=20=20=20=20=20 + + ; + _CharT* __beg =3D __result; + __result +=3D __it._M_sbuf->sgetn(__beg, __n); +=20=20=20=20=20 + + ; + 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 =3D traits_type::eof(); + + if (__first._M_sbuf && !__last._M_sbuf) + { + const int_type __ival =3D traits_type::to_int_type(__val); + streambuf_type* __sb =3D __first._M_sbuf; + int_type __c =3D __sb->sgetc(); + while (!traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __ival)) + { + streamsize __n =3D __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + const _CharT* __p =3D traits_type::find(__sb->gptr(), + __n, __val); + if (__p) + __n =3D __p - __sb->gptr(); + __sb->__safe_gbump(__n); + __c =3D __sb->sgetc(); + } + else + __c =3D __sb->snextc(); + } + + __first._M_c =3D __eof; + } + + return __first; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + void>::__type + advance(istreambuf_iterator<_CharT>& __i, _Distance __n) + { + if (__n =3D=3D 0) + return; + + do { if (std::__is_constant_evaluated() && !bool(__n > 0)) __builtin= _unreachable(); } while (false); +=20=20=20=20=20 + + ; + + 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 =3D traits_type::eof(); + + streambuf_type* __sb =3D __i._M_sbuf; + while (__n > 0) + { + streamsize __size =3D __sb->egptr() - __sb->gptr(); + if (__size > __n) + { + __sb->__safe_gbump(__n); + break; + } + + __sb->__safe_gbump(__size); + __n -=3D __size; + if (traits_type::eq_int_type(__sb->underflow(), __eof)) + { +=20=20=20=20=20=20 + + ; + break; + } + } + + __i._M_c =3D __eof; + } + + + + +} +# 49 "/usr/include/c++/13/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/13/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 =3D 0; __j < __len; __j++, ++__s) + *__s =3D __ws[__j]; + return __s; + } +# 152 "/usr/include/c++/13/bits/locale_facets.h" 3 + template + class __ctype_abstract_base : public locale::facet, public ctype_base + { + public: + + + typedef _CharT char_type; +# 171 "/usr/include/c++/13/bits/locale_facets.h" 3 + bool + is(mask __m, char_type __c) const + { return this->do_is(__m, __c); } +# 188 "/usr/include/c++/13/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); } +# 204 "/usr/include/c++/13/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); } +# 220 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char_type* + scan_not(mask __m, const char_type* __lo, const char_type* __hi) con= st + { return this->do_scan_not(__m, __lo, __hi); } +# 234 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 249 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 263 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 278 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 295 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { return this->do_widen(__c); } +# 314 "/usr/include/c++/13/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); } +# 333 "/usr/include/c++/13/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { return this->do_narrow(__c, __dfault); } +# 355 "/usr/include/c++/13/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 =3D 0): facet(__refs) { } + + virtual + ~__ctype_abstract_base() { } +# 380 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const =3D 0; +# 399 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, + mask* __vec) const =3D 0; +# 418 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, + const char_type* __hi) const =3D 0; +# 437 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const =3D 0; +# 455 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const =3D 0; +# 472 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const =3D 0; +# 488 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const =3D 0; +# 505 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const =3D 0; +# 524 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const =3D 0; +# 545 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const = =3D 0; +# 566 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const =3D 0; +# 591 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const =3D 0; + }; +# 614 "/usr/include/c++/13/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 =3D 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) con= st; + + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) c= onst; + + 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) cons= t; + + 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 >; +# 688 "/usr/include/c++/13/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 =3D 1 + static_cast(-1= ); +# 725 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + ctype(const mask* __table =3D 0, bool __del =3D false, size_t __refs= =3D 0); +# 738 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, const mask* __table =3D 0, bool __del =3D f= alse, + size_t __refs =3D 0); +# 751 "/usr/include/c++/13/bits/locale_facets.h" 3 + inline bool + is(mask __m, char __c) const; +# 766 "/usr/include/c++/13/bits/locale_facets.h" 3 + inline const char* + is(const char* __lo, const char* __hi, mask* __vec) const; +# 780 "/usr/include/c++/13/bits/locale_facets.h" 3 + inline const char* + scan_is(mask __m, const char* __lo, const char* __hi) const; +# 794 "/usr/include/c++/13/bits/locale_facets.h" 3 + inline const char* + scan_not(mask __m, const char* __lo, const char* __hi) const; +# 809 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 826 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 842 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 859 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 879 "/usr/include/c++/13/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); + } +# 906 "/usr/include/c++/13/bits/locale_facets.h" 3 + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (_M_widen_ok =3D=3D 1) + { + if (__builtin_expect(__hi !=3D __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_widen_ok) + _M_widen_init(); + return this->do_widen(__lo, __hi, __to); + } +# 938 "/usr/include/c++/13/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 =3D do_narrow(__c, __dfault); + if (__t !=3D __dfault) + _M_narrow[static_cast(__c)] =3D __t; + return __t; + } +# 971 "/usr/include/c++/13/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 =3D=3D 1, true)) + { + if (__builtin_expect(__hi !=3D __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(); +# 1021 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1038 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1054 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1071 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1091 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const + { return __c; } +# 1114 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (__builtin_expect(__hi !=3D __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } +# 1141 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault __attribute__((__unused__))) = const + { return __c; } +# 1167 "/usr/include/c++/13/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 !=3D __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + + private: + void _M_narrow_init() const; + void _M_widen_init() const; + }; +# 1193 "/usr/include/c++/13/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; +# 1226 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + ctype(size_t __refs =3D 0); +# 1237 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, size_t __refs =3D 0); + + protected: + __wmask_type + _M_convert_to_wmask(const mask __m) const throw(); + + + virtual + ~ctype(); +# 1261 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const; +# 1280 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) con= st; +# 1298 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) c= onst; +# 1316 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; +# 1333 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1350 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1366 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1383 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1403 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const; +# 1425 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const; +# 1448 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const; +# 1474 "/usr/include/c++/13/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 =3D 0); + + + explicit + ctype_byname(const string& __s, size_t __refs =3D 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 =3D 0); + + + explicit + ctype_byname(const string& __s, size_t __refs =3D 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs =3D 0); + + + explicit + ctype_byname(const string& __s, size_t __refs =3D 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + +} + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/ctype_inline.h" 1 3 +# 37 "/usr/include/riscv64-linux-gnu/c++/13/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++ =3D _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) !=3D 0) + ++__low; + return __low; + } + + +} +# 1547 "/usr/include/c++/13/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 =3D _S_odigits + 16, + _S_oudigits =3D _S_odigits_end, + _S_oudigits_end =3D _S_oudigits + 16, + _S_oe =3D _S_odigits + 14, + _S_oE =3D _S_oudigits + 14, + _S_oend =3D _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 =3D _S_izero + 14, + _S_iE =3D _S_izero + 20, + _S_iend =3D 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 =3D 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=3D(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 { +# 1677 "/usr/include/c++/13/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 =3D 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(); } +# 1715 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + numpunct(__cache_type* __cache, size_t __refs =3D 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_numpunct(); } +# 1729 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + numpunct(__c_locale __cloc, size_t __refs =3D 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(__cloc); } +# 1743 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + decimal_point() const + { return this->do_decimal_point(); } +# 1756 "/usr/include/c++/13/bits/locale_facets.h" 3 + char_type + thousands_sep() const + { return this->do_thousands_sep(); } +# 1787 "/usr/include/c++/13/bits/locale_facets.h" 3 + string + grouping() const + { return this->do_grouping(); } +# 1800 "/usr/include/c++/13/bits/locale_facets.h" 3 + string_type + truename() const + { return this->do_truename(); } +# 1813 "/usr/include/c++/13/bits/locale_facets.h" 3 + string_type + falsename() const + { return this->do_falsename(); } + + protected: + + virtual + ~numpunct(); +# 1830 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } +# 1842 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } +# 1855 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual string + do_grouping() const + { return _M_data->_M_grouping; } +# 1868 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual string_type + do_truename() const + { return _M_data->_M_truename; } +# 1881 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual string_type + do_falsename() const + { return _M_data->_M_falsename; } + + + void + _M_initialize_numpunct(__c_locale __cloc =3D 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 =3D 0) + : numpunct<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") !=3D 0 + && __builtin_strcmp(__s, "POSIX") !=3D 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 =3D 0) + : numpunct_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~numpunct_byname() { } + }; + +} + + +# 1959 "/usr/include/c++/13/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; +# 1980 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + num_get(size_t __refs =3D 0) : facet(__refs) { } +# 2006 "/usr/include/c++/13/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); } +# 2043 "/usr/include/c++/13/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); } + + + 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); } +# 2103 "/usr/include/c++/13/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); } +# 2146 "/usr/include/c++/13/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 =3D -1; + if (__len <=3D 10) + { + if (__c >=3D _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) + __ret =3D __c - _CharT2('0'); + } + else + { + if (__c >=3D _CharT2('0') && __c <=3D _CharT2('9')) + __ret =3D __c - _CharT2('0'); + else if (__c >=3D _CharT2('a') && __c <=3D _CharT2('f')) + __ret =3D 10 + (__c - _CharT2('a')); + else if (__c >=3D _CharT2('A') && __c <=3D _CharT2('F')) + __ret =3D 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 =3D -1; + const char_type* __q =3D char_traits<_CharT2>::find(__zero, __len, __c); + if (__q) + { + __ret =3D __q - __zero; + if (__ret > 15) + __ret -=3D 6; + } + return __ret; + } +# 2219 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) c= onst; + + 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); } + + + 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); } + + + 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; +# 2271 "/usr/include/c++/13/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; +# 2299 "/usr/include/c++/13/bits/locale_facets.h" 3 + }; + + template + locale::id num_get<_CharT, _InIter>::id; +# 2317 "/usr/include/c++/13/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; +# 2338 "/usr/include/c++/13/bits/locale_facets.h" 3 + explicit + num_put(size_t __refs =3D 0) : facet(__refs) { } +# 2356 "/usr/include/c++/13/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); } +# 2398 "/usr/include/c++/13/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); } + + + 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); } +# 2461 "/usr/include/c++/13/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, double __v) con= st + { 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); } +# 2486 "/usr/include/c++/13/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() { } +# 2534 "/usr/include/c++/13/bits/locale_facets.h" 3 + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) co= nst; + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) co= nst + { 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); } + + + 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); } + + + 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; +# 2586 "/usr/include/c++/13/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++/13/bits/locale_facets.tcc" 1 3 +# 33 "/usr/include/c++/13/bits/locale_facets.tcc" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/locale_facets.tcc" 3 + +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 =3D numpunct<_CharT>::id._M_id(); + const locale::facet** __caches =3D __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __numpunct_cache<_CharT>* __tmp =3D 0; + if (true) + { + __tmp =3D new __numpunct_cache<_CharT>; + __tmp->_M_cache(__loc); + } + if (false) + { + delete __tmp; + ; + } + __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 =3D use_facet >(__loc); + + char* __grouping =3D 0; + _CharT* __truename =3D 0; + _CharT* __falsename =3D 0; + if (true) + { + const string& __g =3D __np.grouping(); + _M_grouping_size =3D __g.size(); + __grouping =3D new char[_M_grouping_size]; + __g.copy(__grouping, _M_grouping_size); + _M_use_grouping =3D (_M_grouping_size + && static_cast(__grouping[0]) > 0 + && (__grouping[0] + !=3D __gnu_cxx::__numeric_traits::__max)); + + const basic_string<_CharT>& __tn =3D __np.truename(); + _M_truename_size =3D __tn.size(); + __truename =3D new _CharT[_M_truename_size]; + __tn.copy(__truename, _M_truename_size); + + const basic_string<_CharT>& __fn =3D __np.falsename(); + _M_falsename_size =3D __fn.size(); + __falsename =3D new _CharT[_M_falsename_size]; + __fn.copy(__falsename, _M_falsename_size); + + _M_decimal_point =3D __np.decimal_point(); + _M_thousands_sep =3D __np.thousands_sep(); + + const ctype<_CharT>& __ct =3D 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 =3D __grouping; + _M_truename =3D __truename; + _M_falsename =3D __falsename; + _M_allocated =3D true; + } + if (false) + { + delete [] __grouping; + delete [] __truename; + delete [] __falsename; + ; + } + } +# 139 "/usr/include/c++/13/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 =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + const _CharT* __lit =3D __lc->_M_atoms_in; + char_type __c =3D char_type(); + + + bool __testeof =3D __beg =3D=3D __end; + + + if (!__testeof) + { + __c =3D *__beg; + const bool __plus =3D __c =3D=3D __lit[__num_base::_S_iplus]; + if ((__plus || __c =3D=3D __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + && !(__c =3D=3D __lc->_M_decimal_point)) + { + __xtrc +=3D __plus ? '+' : '-'; + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + } + + + bool __found_mantissa =3D false; + int __sep_pos =3D 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + || __c =3D=3D __lc->_M_decimal_point) + break; + else if (__c =3D=3D __lit[__num_base::_S_izero]) + { + if (!__found_mantissa) + { + __xtrc +=3D '0'; + __found_mantissa =3D true; + } + ++__sep_pos; + + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + else + break; + } + + + bool __found_dec =3D false; + bool __found_sci =3D false; + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + const char_type* __lit_zero =3D __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + const int __digit =3D _M_find(__lit_zero, 10, __c); + if (__digit !=3D -1) + { + __xtrc +=3D '0' + __digit; + __found_mantissa =3D true; + } + else if (__c =3D=3D __lc->_M_decimal_point + && !__found_dec && !__found_sci) + { + __xtrc +=3D '.'; + __found_dec =3D true; + } + else if ((__c =3D=3D __lit[__num_base::_S_ie] + || __c =3D=3D __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + __xtrc +=3D 'e'; + __found_sci =3D true; + + + if (++__beg !=3D __end) + { + __c =3D *__beg; + const bool __plus =3D __c =3D=3D __lit[__num_base::_S_iplus]; + if (__plus || __c =3D=3D __lit[__num_base::_S_iminus]) + __xtrc +=3D __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof =3D true; + break; + } + } + else + break; + + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + { + if (!__found_dec && !__found_sci) + { + + + if (__sep_pos) + { + __found_grouping +=3D static_cast(__sep_pos); + __sep_pos =3D 0; + } + else + { + + + __xtrc.clear(); + break; + } + } + else + break; + } + else if (__c =3D=3D __lc->_M_decimal_point) + { + if (!__found_dec && !__found_sci) + { + + + + if (__found_grouping.size()) + __found_grouping +=3D static_cast(__sep_pos); + __xtrc +=3D '.'; + __found_dec =3D true; + } + else + break; + } + else + { + const char_type* __q =3D + __traits_type::find(__lit_zero, 10, __c); + if (__q) + { + __xtrc +=3D '0' + (__q - __lit_zero); + __found_mantissa =3D true; + ++__sep_pos; + } + else if ((__c =3D=3D __lit[__num_base::_S_ie] + || __c =3D=3D __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + if (__found_grouping.size() && !__found_dec) + __found_grouping +=3D static_cast(__sep_pos); + __xtrc +=3D 'e'; + __found_sci =3D true; + + + if (++__beg !=3D __end) + { + __c =3D *__beg; + const bool __plus =3D __c =3D=3D __lit[__num_base::_S_iplus]; + if ((__plus || __c =3D=3D __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping + && __c =3D=3D __lc->_M_thousands_sep) + && !(__c =3D=3D __lc->_M_decimal_point)) + __xtrc +=3D __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof =3D true; + break; + } + } + else + break; + } + + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + + + + if (__found_grouping.size()) + { + + if (!__found_dec && !__found_sci) + __found_grouping +=3D static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err =3D 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 =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + const _CharT* __lit =3D __lc->_M_atoms_in; + char_type __c =3D char_type(); + + + const ios_base::fmtflags __basefield =3D __io.flags() + & ios_base::basefield; + const bool __oct =3D __basefield =3D=3D ios_base::oct; + int __base =3D __oct ? 8 : (__basefield =3D=3D ios_base::hex ? 16 : 10); + + + bool __testeof =3D __beg =3D=3D __end; + + + bool __negative =3D false; + if (!__testeof) + { + __c =3D *__beg; + __negative =3D __c =3D=3D __lit[__num_base::_S_iminus]; + if ((__negative || __c =3D=3D __lit[__num_base::_S_iplus]) + && !(__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + && !(__c =3D=3D __lc->_M_decimal_point)) + { + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + } + + + + bool __found_zero =3D false; + int __sep_pos =3D 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + || __c =3D=3D __lc->_M_decimal_point) + break; + else if (__c =3D=3D __lit[__num_base::_S_izero] + && (!__found_zero || __base =3D=3D 10)) + { + __found_zero =3D true; + ++__sep_pos; + if (__basefield =3D=3D 0) + __base =3D 8; + if (__base =3D=3D 8) + __sep_pos =3D 0; + } + else if (__found_zero + && (__c =3D=3D __lit[__num_base::_S_ix] + || __c =3D=3D __lit[__num_base::_S_iX])) + { + if (__basefield =3D=3D 0) + __base =3D 16; + if (__base =3D=3D 16) + { + __found_zero =3D false; + __sep_pos =3D 0; + } + else + break; + } + else + break; + + if (++__beg !=3D __end) + { + __c =3D *__beg; + if (!__found_zero) + break; + } + else + __testeof =3D true; + } + + + + const size_t __len =3D (__base =3D=3D 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 =3D false; + bool __testoverflow =3D false; + const __unsigned_type __max =3D + (__negative && __num_traits::__is_signed) + ? -static_cast<__unsigned_type>(__num_traits::__min) + : __num_traits::__max; + const __unsigned_type __smax =3D __max / __base; + __unsigned_type __result =3D 0; + int __digit =3D 0; + const char_type* __lit_zero =3D __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + __digit =3D _M_find(__lit_zero, __len, __c); + if (__digit =3D=3D -1) + break; + + if (__result > __smax) + __testoverflow =3D true; + else + { + __result *=3D __base; + __testoverflow |=3D __result > __max - __digit; + __result +=3D __digit; + ++__sep_pos; + } + + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c =3D=3D __lc->_M_thousands_sep) + { + + + if (__sep_pos) + { + __found_grouping +=3D static_cast(__sep_pos); + __sep_pos =3D 0; + } + else + { + __testfail =3D true; + break; + } + } + else if (__c =3D=3D __lc->_M_decimal_point) + break; + else + { + const char_type* __q =3D + __traits_type::find(__lit_zero, __len, __c); + if (!__q) + break; + + __digit =3D __q - __lit_zero; + if (__digit > 15) + __digit -=3D 6; + if (__result > __smax) + __testoverflow =3D true; + else + { + __result *=3D __base; + __testoverflow |=3D __result > __max - __digit; + __result +=3D __digit; + ++__sep_pos; + } + } + + if (++__beg !=3D __end) + __c =3D *__beg; + else + __testeof =3D true; + } + + + + if (__found_grouping.size()) + { + + __found_grouping +=3D static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err =3D ios_base::failbit; + } + + + + if ((!__sep_pos && !__found_zero && !__found_grouping.size()) + || __testfail) + { + __v =3D 0; + __err =3D ios_base::failbit; + } + else if (__testoverflow) + { + if (__negative && __num_traits::__is_signed) + __v =3D __num_traits::__min; + else + __v =3D __num_traits::__max; + __err =3D ios_base::failbit; + } + else + __v =3D __negative ? -__result : __result; + + if (__testeof) + __err |=3D 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 =3D -1; + __beg =3D _M_extract_int(__beg, __end, __io, __err, __l); + if (__l =3D=3D 0 || __l =3D=3D 1) + __v =3D bool(__l); + else + { + + + __v =3D true; + __err =3D ios_base::failbit; + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + } + } + else + { + + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + + bool __testf =3D true; + bool __testt =3D true; + bool __donef =3D __lc->_M_falsename_size =3D=3D 0; + bool __donet =3D __lc->_M_truename_size =3D=3D 0; + bool __testeof =3D false; + size_t __n =3D 0; + while (!__donef || !__donet) + { + if (__beg =3D=3D __end) + { + __testeof =3D true; + break; + } + + const char_type __c =3D *__beg; + + if (!__donef) + __testf =3D __c =3D=3D __lc->_M_falsename[__n]; + + if (!__testf && __donet) + break; + + if (!__donet) + __testt =3D __c =3D=3D __lc->_M_truename[__n]; + + if (!__testt && __donef) + break; + + if (!__testt && !__testf) + break; + + ++__n; + ++__beg; + + __donef =3D !__testf || __n >=3D __lc->_M_falsename_size; + __donet =3D !__testt || __n >=3D __lc->_M_truename_size; + } + if (__testf && __n =3D=3D __lc->_M_falsename_size && __n) + { + __v =3D false; + if (__testt && __n =3D=3D __lc->_M_truename_size) + __err =3D ios_base::failbit; + else + __err =3D __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else if (__testt && __n =3D=3D __lc->_M_truename_size && __n) + { + __v =3D true; + __err =3D __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else + { + + + __v =3D false; + __err =3D ios_base::failbit; + if (__testeof) + __err |=3D 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 =3D _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg =3D=3D __end) + __err |=3D 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 =3D _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } +# 735 "/usr/include/c++/13/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 =3D _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg =3D=3D __end) + __err |=3D 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 =3D __io.flags(); + __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); + + typedef __gnu_cxx::__conditional_type<(sizeof(void*) + <=3D sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + _UIntPtrType __ul; + __beg =3D _M_extract_int(__beg, __end, __io, __err, __ul); + + + __io.flags(__fmt); + + __v =3D reinterpret_cast(__ul); + return __beg; + } +# 795 "/usr/include/c++/13/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 =3D static_cast(__w); + } + + + + template + int + __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, + ios_base::fmtflags __flags, bool __dec) + { + _CharT* __buf =3D __bufend; + if (__builtin_expect(__dec, true)) + { + + do + { + *--__buf =3D __lit[(__v % 10) + __num_base::_S_odigits]; + __v /=3D 10; + } + while (__v !=3D 0); + } + else if ((__flags & ios_base::basefield) =3D=3D ios_base::oct) + { + + do + { + *--__buf =3D __lit[(__v & 0x7) + __num_base::_S_odigits]; + __v >>=3D 3; + } + while (__v !=3D 0); + } + else + { + + const bool __uppercase =3D __flags & ios_base::uppercase; + const int __case_offset =3D __uppercase ? __num_base::_S_oudigits + : __num_base::_S_odigits; + do + { + *--__buf =3D __lit[(__v & 0xf) + __case_offset]; + __v >>=3D 4; + } + while (__v !=3D 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 =3D std::__add_grouping(__new, __sep, __grouping, + __grouping_size, __cs, __cs + __len); + __len =3D __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 =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + const _CharT* __lit =3D __lc->_M_atoms_out; + const ios_base::fmtflags __flags =3D __io.flags(); + + + const int __ilen =3D 5 * sizeof(_ValueT); + _CharT* __cs =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __ilen)); + + + + const ios_base::fmtflags __basefield =3D __flags & ios_base::basefield; + const bool __dec =3D (__basefield !=3D ios_base::oct + && __basefield !=3D ios_base::hex); + const __unsigned_type __u =3D ((__v > 0 || !__dec) + ? __unsigned_type(__v) + : -__unsigned_type(__v)); + int __len =3D __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); + __cs +=3D __ilen - __len; + + + if (__lc->_M_use_grouping) + { + + + _CharT* __cs2 =3D 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 =3D __cs2 + 2; + } + + + if (__builtin_expect(__dec, true)) + { + + if (__v >=3D 0) + { + if (bool(__flags & ios_base::showpos) + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + *--__cs =3D __lit[__num_base::_S_oplus], ++__len; + } + else + *--__cs =3D __lit[__num_base::_S_ominus], ++__len; + } + else if (bool(__flags & ios_base::showbase) && __v) + { + if (__basefield =3D=3D ios_base::oct) + *--__cs =3D __lit[__num_base::_S_odigits], ++__len; + else + { + + const bool __uppercase =3D __flags & ios_base::uppercase; + *--__cs =3D __lit[__num_base::_S_ox + __uppercase]; + + *--__cs =3D __lit[__num_base::_S_odigits]; + __len +=3D 2; + } + } + + + const streamsize __w =3D __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __cs3 =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs =3D __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 =3D __p ? __p - __cs : __len; + _CharT* __p2 =3D std::__add_grouping(__new, __sep, __grouping, + __grouping_size, + __cs, __cs + __declen); + + + int __newlen =3D __p2 - __new; + if (__p) + { + char_traits<_CharT>::copy(__p2, __p, __len - __declen); + __newlen +=3D __len - __declen; + } + __len =3D __newlen; + } +# 989 "/usr/include/c++/13/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 =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + + + const streamsize __prec =3D __io.precision() < 0 ? 6 : __io.precision(); + + const int __max_digits =3D + __gnu_cxx::__numeric_traits<_ValueT>::__digits10; + + + int __len; + + char __fbuf[16]; + __num_base::_S_format_float(__io, __fbuf, __mod); + + + + const bool __use_prec =3D + (__io.flags() & ios_base::floatfield) !=3D ios_base::floatfield; + + + + int __cs_size =3D __max_digits * 3; + char* __cs =3D static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + + + if (__len >=3D __cs_size) + { + __cs_size =3D __len + 1; + __cs =3D static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + } +# 1062 "/usr/include/c++/13/bits/locale_facets.tcc" 3 + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + _CharT* __ws =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __ctype.widen(__cs, __cs + __len, __ws); + + + _CharT* __wp =3D 0; + const char* __p =3D char_traits::find(__cs, __len, '.'); + if (__p) + { + __wp =3D __ws + (__p - __cs); + *__wp =3D __lc->_M_decimal_point; + } + + + + + if (__lc->_M_use_grouping + && (__wp || __len < 3 || (__cs[1] <=3D '9' && __cs[2] <=3D '9' + && __cs[1] >=3D '0' && __cs[2] >=3D '0'))) + { + + + _CharT* __ws2 =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + + streamsize __off =3D 0; + if (__cs[0] =3D=3D '-' || __cs[0] =3D=3D '+') + { + __off =3D 1; + __ws2[0] =3D __ws[0]; + __len -=3D 1; + } + + _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __wp, __ws2 + __off, + __ws + __off, __len); + __len +=3D __off; + + __ws =3D __ws2; + } + + + const streamsize __w =3D __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __ws3 =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws =3D __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 =3D __io.flags(); + if ((__flags & ios_base::boolalpha) =3D=3D 0) + { + const long __l =3D __v; + __s =3D _M_insert_int(__s, __io, __fill, __l); + } + else + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc =3D __io._M_getloc(); + const __cache_type* __lc =3D __uc(__loc); + + const _CharT* __name =3D __v ? __lc->_M_truename + : __lc->_M_falsename; + int __len =3D __v ? __lc->_M_truename_size + : __lc->_M_falsename_size; + + const streamsize __w =3D __io.width(); + if (__w > static_cast(__len)) + { + const streamsize __plen =3D __w - __len; + _CharT* __ps + =3D static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __plen)); + + char_traits<_CharT>::assign(__ps, __plen, __fill); + __io.width(0); + + if ((__flags & ios_base::adjustfield) =3D=3D ios_base::left) + { + __s =3D std::__write(__s, __name, __len); + __s =3D std::__write(__s, __ps, __plen); + } + else + { + __s =3D std::__write(__s, __ps, __plen); + __s =3D std::__write(__s, __name, __len); + } + return __s; + } + __io.width(0); + __s =3D 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) co= nst + { return _M_insert_float(__s, __io, __fill, char(), __v); } +# 1187 "/usr/include/c++/13/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 =3D __io.flags(); + const ios_base::fmtflags __fmt =3D ~(ios_base::basefield + | ios_base::uppercase); + __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); + + typedef __gnu_cxx::__conditional_type<(sizeof(const void*) + <=3D sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + __s =3D _M_insert_int(__s, __io, __fill, + reinterpret_cast<_UIntPtrType>(__v)); + __io.flags(__flags); + return __s; + } +# 1224 "/usr/include/c++/13/bits/locale_facets.tcc" 3 + +# 1233 "/usr/include/c++/13/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 =3D static_cast(__newlen - __oldlen); + const ios_base::fmtflags __adjust =3D __io.flags() & ios_base::adjus= tfield; + + + if (__adjust =3D=3D ios_base::left) + { + _Traits::copy(__news, __olds, __oldlen); + _Traits::assign(__news + __oldlen, __plen, __fill); + return; + } + + size_t __mod =3D 0; + if (__adjust =3D=3D ios_base::internal) + { + + + + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + if (__ctype.widen('-') =3D=3D __olds[0] + || __ctype.widen('+') =3D=3D __olds[0]) + { + __news[0] =3D __olds[0]; + __mod =3D 1; + ++__news; + } + else if (__ctype.widen('0') =3D=3D __olds[0] + && __oldlen > 1 + && (__ctype.widen('x') =3D=3D __olds[1] + || __ctype.widen('X') =3D=3D __olds[1])) + { + __news[0] =3D __olds[0]; + __news[1] =3D __olds[1]; + __mod =3D 2; + __news +=3D 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 =3D 0; + size_t __ctr =3D 0; + + while (__last - __first > __gbeg[__idx] + && static_cast(__gbeg[__idx]) > 0 + && __gbeg[__idx] !=3D __gnu_cxx::__numeric_traits::__max) + { + __last -=3D __gbeg[__idx]; + __idx < __gsize - 1 ? ++__idx : ++__ctr; + } + + while (__first !=3D __last) + *__s++ =3D *__first++; + + while (__ctr--) + { + *__s++ =3D __sep; + for (char __i =3D __gbeg[__idx]; __i > 0; --__i) + *__s++ =3D *__first++; + } + + while (__idx--) + { + *__s++ =3D __sep; + for (char __i =3D __gbeg[__idx]; __i > 0; --__i) + *__s++ =3D *__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&); + + + + +} +# 2688 "/usr/include/c++/13/bits/locale_facets.h" 2 3 +# 38 "/usr/include/c++/13/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; + } +# 66 "/usr/include/c++/13/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: +# 117 "/usr/include/c++/13/bits/basic_ios.h" 3 + explicit operator bool() const + { return !this->fail(); } + + + + + + bool + operator!() const + { return this->fail(); } +# 136 "/usr/include/c++/13/bits/basic_ios.h" 3 + iostate + rdstate() const + { return _M_streambuf_state; } +# 147 "/usr/include/c++/13/bits/basic_ios.h" 3 + void + clear(iostate __state =3D goodbit); + + + + + + + + void + setstate(iostate __state) + { this->clear(this->rdstate() | __state); } + + + + + void + _M_setstate(iostate __state) + { + + + _M_streambuf_state |=3D __state; + if (this->exceptions() & __state) + ; + } + + + + + + + + bool + good() const + { return this->rdstate() =3D=3D 0; } + + + + + + + + bool + eof() const + { return (this->rdstate() & eofbit) !=3D 0; } +# 200 "/usr/include/c++/13/bits/basic_ios.h" 3 + bool + fail() const + { return (this->rdstate() & (badbit | failbit)) !=3D 0; } + + + + + + + + bool + bad() const + { return (this->rdstate() & badbit) !=3D 0; } +# 221 "/usr/include/c++/13/bits/basic_ios.h" 3 + iostate + exceptions() const + { return _M_exception; } +# 256 "/usr/include/c++/13/bits/basic_ios.h" 3 + void + exceptions(iostate __except) + { + _M_exception =3D __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_streambu= f(0), + _M_ctype(0), _M_num_put(0), _M_num_get(0) + { this->init(__sb); } + + + + + + + + virtual + ~basic_ios() { } +# 294 "/usr/include/c++/13/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie() const + { return _M_tie; } +# 306 "/usr/include/c++/13/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie(basic_ostream<_CharT, _Traits>* __tiestr) + { + basic_ostream<_CharT, _Traits>* __old =3D _M_tie; + _M_tie =3D __tiestr; + return __old; + } + + + + + + + + basic_streambuf<_CharT, _Traits>* + rdbuf() const + { return _M_streambuf; } +# 346 "/usr/include/c++/13/bits/basic_ios.h" 3 + basic_streambuf<_CharT, _Traits>* + rdbuf(basic_streambuf<_CharT, _Traits>* __sb); +# 360 "/usr/include/c++/13/bits/basic_ios.h" 3 + basic_ios& + copyfmt(const basic_ios& __rhs); + + + + + + + + char_type + fill() const + { + if (!_M_fill_init) + { + _M_fill =3D this->widen(' '); + _M_fill_init =3D true; + } + return _M_fill; + } +# 389 "/usr/include/c++/13/bits/basic_ios.h" 3 + char_type + fill(char_type __ch) + { + char_type __old =3D this->fill(); + _M_fill =3D __ch; + return __old; + } +# 409 "/usr/include/c++/13/bits/basic_ios.h" 3 + locale + imbue(const locale& __loc); +# 429 "/usr/include/c++/13/bits/basic_ios.h" 3 + char + narrow(char_type __c, char __dfault) const + { return __check_facet(_M_ctype).narrow(__c, __dfault); } +# 448 "/usr/include/c++/13/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&) =3D delete; + basic_ios& operator=3D(const basic_ios&) =3D delete; + + void + move(basic_ios& __rhs) + { + ios_base::_M_move(__rhs); + _M_cache_locale(_M_ios_locale); + this->tie(__rhs.tie(nullptr)); + _M_fill =3D __rhs._M_fill; + _M_fill_init =3D __rhs._M_fill_init; + _M_streambuf =3D 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 =3D __sb; } + + + void + _M_cache_locale(const locale& __loc); + }; + + +} + +# 1 "/usr/include/c++/13/bits/basic_ios.tcc" 1 3 +# 33 "/usr/include/c++/13/bits/basic_ios.tcc" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/basic_ios.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + void + basic_ios<_CharT, _Traits>::clear(iostate __state) + { + if (this->rdbuf()) + _M_streambuf_state =3D __state; + else + _M_streambuf_state =3D __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 =3D _M_streambuf; + _M_streambuf =3D __sb; + this->clear(); + return __old; + } + + template + basic_ios<_CharT, _Traits>& + basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) + { + + + if (this !=3D std::__addressof(__rhs)) + { + + + + + _Words* __words =3D (__rhs._M_word_size <=3D _S_local_word_size) ? + _M_local_word : new _Words[__rhs._M_word_size]; + + + _Callback_list* __cb =3D __rhs._M_callbacks; + if (__cb) + __cb->_M_add_reference(); + _M_call_callbacks(erase_event); + if (_M_word !=3D _M_local_word) + { + delete [] _M_word; + _M_word =3D 0; + } + _M_dispose_callbacks(); + + + _M_callbacks =3D __cb; + for (int __i =3D 0; __i < __rhs._M_word_size; ++__i) + __words[__i] =3D __rhs._M_word[__i]; + _M_word =3D __words; + _M_word_size =3D __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 =3D __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() !=3D 0) + this->rdbuf()->pubimbue(__loc); + return __old; + } + + template + void + basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __s= b) + { + + ios_base::_M_init(); + + + _M_cache_locale(_M_ios_locale); +# 146 "/usr/include/c++/13/bits/basic_ios.tcc" 3 + _M_fill =3D _CharT(); + _M_fill_init =3D false; + + _M_tie =3D 0; + _M_exception =3D goodbit; + _M_streambuf =3D __sb; + _M_streambuf_state =3D __sb ? goodbit : badbit; + } + + template + void + basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) + { + _M_ctype =3D std::__try_use_facet<__ctype_type>(__loc); + _M_num_put =3D std::__try_use_facet<__num_put_type>(__loc); + _M_num_get =3D std::__try_use_facet<__num_get_type>(__loc); + } + + + + + extern template class basic_ios; + + + extern template class basic_ios; + + + + +} +# 517 "/usr/include/c++/13/bits/basic_ios.h" 2 3 +# 47 "/usr/include/c++/13/ios" 2 3 +# 41 "/usr/include/c++/13/ostream" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/13/ostream" 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; +# 85 "/usr/include/c++/13/ostream" 3 + explicit + basic_ostream(__streambuf_type* __sb) + { this->init(__sb); } + + + + + + + virtual + ~basic_ostream() { } + + + class sentry; + friend class sentry; +# 109 "/usr/include/c++/13/ostream" 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; + } +# 167 "/usr/include/c++/13/ostream" 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)); + } + + + __ostream_type& + operator<<(long long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long long __n) + { return _M_insert(__n); } +# 221 "/usr/include/c++/13/ostream" 3 + __ostream_type& + operator<<(double __f) + { return _M_insert(__f); } + + __ostream_type& + operator<<(float __f) + { + + + return _M_insert(static_cast(__f)); + } + + __ostream_type& + operator<<(long double __f) + { return _M_insert(__f); } +# 291 "/usr/include/c++/13/ostream" 3 + __ostream_type& + operator<<(const void* __p) + { return _M_insert(__p); } + + + __ostream_type& + operator<<(nullptr_t) + { return *this << "nullptr"; } +# 329 "/usr/include/c++/13/ostream" 3 + __ostream_type& + operator<<(__streambuf_type* __sb); +# 362 "/usr/include/c++/13/ostream" 3 + __ostream_type& + put(char_type __c); +# 381 "/usr/include/c++/13/ostream" 3 + __ostream_type& + write(const char_type* __s, streamsize __n); +# 394 "/usr/include/c++/13/ostream" 3 + __ostream_type& + flush(); +# 404 "/usr/include/c++/13/ostream" 3 + pos_type + tellp(); +# 415 "/usr/include/c++/13/ostream" 3 + __ostream_type& + seekp(pos_type); +# 427 "/usr/include/c++/13/ostream" 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&) =3D delete; + + basic_ostream(basic_ostream&& __rhs) + : __ios_type() + { __ios_type::move(__rhs); } + + + + basic_ostream& operator=3D(const basic_ostream&) =3D delete; + + basic_ostream& + operator=3D(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); } + + }; +# 479 "/usr/include/c++/13/ostream" 3 + template + class basic_ostream<_CharT, _Traits>::sentry + { + + bool _M_ok; + basic_ostream<_CharT, _Traits>& _M_os; + + public: +# 498 "/usr/include/c++/13/ostream" 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) && !uncaught_exception()) + { + + if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() =3D=3D -1) + _M_os.setstate(ios_base::badbit); + } + } +#pragma GCC diagnostic pop +# 530 "/usr/include/c++/13/ostream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 552 "/usr/include/c++/13/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) + { + if (__out.width() !=3D 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() !=3D 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)); } +# 643 "/usr/include/c++/13/ostream" 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)); } +# 733 "/usr/include/c++/13/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + endl(basic_ostream<_CharT, _Traits>& __os) + { return flush(__os.put(__os.widen('\n'))); } +# 745 "/usr/include/c++/13/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(); } +# 777 "/usr/include/c++/13/ostream" 3 + template + using _Require_derived_from_ios_base + =3D _Require, __not_>, + is_convertible::type, ios_base*>>; + + template, + typename + =3D decltype(std::declval<_Os&>() << std::declval())> + using __rvalue_stream_insertion_t =3D _Os&&; +# 799 "/usr/include/c++/13/ostream" 3 + template + inline __rvalue_stream_insertion_t<_Ostream, _Tp> + operator<<(_Ostream&& __os, const _Tp& __x) + { + __os << __x; + return std::move(__os); + } +# 877 "/usr/include/c++/13/ostream" 3 + +} + +# 1 "/usr/include/c++/13/bits/ostream.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/ostream.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/ostream.tcc" 3 + + + +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 =3D 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 =3D ios_base::goodbit; + if (true) + { + + const __num_put_type& __np =3D __check_facet(this->_M_num_put); + + + + + if (__np.put(*this, *this, this->fill(), __v).failed()) + __err |=3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D this->flags() & ios_base::basefie= ld; + if (__fmt =3D=3D ios_base::oct || __fmt =3D=3D 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 =3D this->flags() & ios_base::basefie= ld; + if (__fmt =3D=3D ios_base::oct || __fmt =3D=3D 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 =3D ios_base::goodbit; + sentry __cerb(*this); + if (__cerb && __sbin) + { + if (true) + { + if (!__copy_streambufs(__sbin, this->rdbuf())) + __err |=3D ios_base::failbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbin) + __err |=3D 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 =3D ios_base::goodbit; + if (true) + { + const int_type __put =3D this->rdbuf()->sputc(__c); + if (traits_type::eq_int_type(__put, traits_type::eof())) + __err |=3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + if (this->rdbuf()->sputn(__s, __n) !=3D __n) + __err =3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D this->rdbuf()) + { + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + if (this->rdbuf()->pubsync() =3D=3D -1) + __err |=3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D pos_type(-1); + if (!this->fail()) + __ret =3D 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 =3D this->rdbuf()->pubseekpos(__pos, ios_base::out); + + + if (__p =3D=3D 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 =3D this->rdbuf()->pubseekoff(__off, __dir, + ios_base::out); + + + if (__p =3D=3D 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 =3D char_traits::length(__s); + if (true) + { + 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 =3D __pg.__get(); + for (size_t __i =3D 0; __i < __clen; ++__i) + __ws[__i] =3D __out.widen(__s[__i]); + __ostream_insert(__out, __ws, __clen); + } + if (false) + { + __out._M_setstate(ios_base::badbit); + ; + } + if (false) + { __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); + + extern template ostream& ostream::_M_insert(long long); + extern template ostream& ostream::_M_insert(unsigned long long); + + 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); + + extern template wostream& wostream::_M_insert(long long); + extern template wostream& wostream::_M_insert(unsigned long long); + + extern template wostream& wostream::_M_insert(double); + extern template wostream& wostream::_M_insert(long double); + extern template wostream& wostream::_M_insert(const void*); + + + + +} +# 881 "/usr/include/c++/13/ostream" 2 3 +# 56 "/usr/include/gtest/gtest.h" 2 3 4 + + + +# 1 "/usr/include/gtest/gtest-assertion-result.h" 1 3 4 +# 46 "/usr/include/gtest/gtest-assertion-result.h" 3 4 +# 1 "/usr/include/gtest/gtest-message.h" 1 3 4 +# 53 "/usr/include/gtest/gtest-message.h" 3 4 +# 1 "/usr/include/c++/13/sstream" 1 3 4 +# 36 "/usr/include/c++/13/sstream" 3 4 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/sstream" 3 + + + +# 1 "/usr/include/c++/13/istream" 1 3 +# 36 "/usr/include/c++/13/istream" 3 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/istream" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/13/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 =3D streamsize(0); } + + + class sentry; + friend class sentry; +# 121 "/usr/include/c++/13/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; + } +# 169 "/usr/include/c++/13/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); } + + + __istream_type& + operator>>(long long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long long& __n) + { return _M_extract(__n); } +# 215 "/usr/include/c++/13/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); } +# 324 "/usr/include/c++/13/istream" 3 + __istream_type& + operator>>(void*& __p) + { return _M_extract(__p); } +# 348 "/usr/include/c++/13/istream" 3 + __istream_type& + operator>>(__streambuf_type* __sb); +# 358 "/usr/include/c++/13/istream" 3 + streamsize + gcount() const + { return _M_gcount; } +# 391 "/usr/include/c++/13/istream" 3 + int_type + get(); +# 405 "/usr/include/c++/13/istream" 3 + __istream_type& + get(char_type& __c); +# 432 "/usr/include/c++/13/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n, char_type __delim); +# 443 "/usr/include/c++/13/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n) + { return this->get(__s, __n, this->widen('\n')); } +# 466 "/usr/include/c++/13/istream" 3 + __istream_type& + get(__streambuf_type& __sb, char_type __delim); +# 476 "/usr/include/c++/13/istream" 3 + __istream_type& + get(__streambuf_type& __sb) + { return this->get(__sb, this->widen('\n')); } +# 505 "/usr/include/c++/13/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n, char_type __delim); +# 516 "/usr/include/c++/13/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n) + { return this->getline(__s, __n, this->widen('\n')); } +# 540 "/usr/include/c++/13/istream" 3 + __istream_type& + ignore(streamsize __n, int_type __delim); + + __istream_type& + ignore(streamsize __n); + + __istream_type& + ignore(); +# 557 "/usr/include/c++/13/istream" 3 + int_type + peek(); +# 575 "/usr/include/c++/13/istream" 3 + __istream_type& + read(char_type* __s, streamsize __n); +# 594 "/usr/include/c++/13/istream" 3 + streamsize + readsome(char_type* __s, streamsize __n); +# 611 "/usr/include/c++/13/istream" 3 + __istream_type& + putback(char_type __c); +# 627 "/usr/include/c++/13/istream" 3 + __istream_type& + unget(); +# 645 "/usr/include/c++/13/istream" 3 + int + sync(); +# 660 "/usr/include/c++/13/istream" 3 + pos_type + tellg(); +# 675 "/usr/include/c++/13/istream" 3 + __istream_type& + seekg(pos_type); +# 691 "/usr/include/c++/13/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&) =3D delete; + + basic_istream(basic_istream&& __rhs) + : __ios_type(), _M_gcount(__rhs._M_gcount) + { + __ios_type::move(__rhs); + __rhs._M_gcount =3D 0; + } + + + + basic_istream& operator=3D(const basic_istream&) =3D delete; + + basic_istream& + operator=3D(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); +# 775 "/usr/include/c++/13/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; +# 811 "/usr/include/c++/13/istream" 3 + explicit + sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws =3D fal= se); +# 822 "/usr/include/c++/13/istream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 840 "/usr/include/c++/13/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); +# 890 "/usr/include/c++/13/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 =3D __builtin_object_size(__s, 0); + if (__n < sizeof(_CharT)) + { + + do { if (std::__is_constant_evaluated() && !bool(__n >=3D sizeof(_CharT= ))) __builtin_unreachable(); } while (false); + + __in.width(0); + __in.setstate(ios_base::failbit); + } + else if (__n !=3D (size_t)-1) + { + __n /=3D sizeof(_CharT); + streamsize __w =3D __in.width(); + std::__istream_extract(__in, __s, __n); + if (__in.good() && (__w <=3D 0 || __n < __w)) + { + + + const typename _Traits::int_type __c =3D __in.rdbuf()->sgetc(); + const bool __eof =3D _Traits::eq_int_type(__c, _Traits::eof()); + if (__builtin_expect(__eof, true)) + __in.setstate(ios_base::eofbit); + } + } + else + + { + + streamsize __n =3D __gnu_cxx::__numeric_traits::__max; + __n /=3D 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); } +# 979 "/usr/include/c++/13/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&) =3D delete; + + basic_iostream(basic_iostream&& __rhs) + : __istream_type(std::move(__rhs)), __ostream_type(*this) + { } + + + + basic_iostream& operator=3D(const basic_iostream&) =3D delete; + + basic_iostream& + operator=3D(basic_iostream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_iostream& __rhs) + { __istream_type::swap(__rhs); } + + }; +# 1062 "/usr/include/c++/13/istream" 3 + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __is); +# 1078 "/usr/include/c++/13/istream" 3 + template, + typename =3D decltype(std::declval<_Is&>() >> std::declval<_Tp>())> + using __rvalue_stream_extraction_t =3D _Is&&; +# 1094 "/usr/include/c++/13/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++/13/bits/istream.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/istream.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/istream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + basic_istream<_CharT, _Traits>::sentry:: + sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(fa= lse) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (__in.good()) + { + if (true) + { + if (__in.tie()) + __in.tie()->flush(); + if (!__noskip && bool(__in.flags() & ios_base::skipws)) + { + const __int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D __in.rdbuf(); + __int_type __c =3D __sb->sgetc(); + + const __ctype_type& __ct =3D __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 =3D __sb->snextc(); + + + + + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + } + } + if (false) + { + __in._M_setstate(ios_base::badbit); + ; + } + if (false) + { __in._M_setstate(ios_base::badbit); } + } + + if (__in.good() && __err =3D=3D ios_base::goodbit) + _M_ok =3D true; + else + { + __err |=3D 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 =3D ios_base::goodbit; + if (true) + { + + const __num_get_type& __ng =3D __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __v); + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + long __l; + + const __num_get_type& __ng =3D __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |=3D ios_base::failbit; + __n =3D __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |=3D ios_base::failbit; + __n =3D __gnu_cxx::__numeric_traits::__max; + } + else + __n =3D short(__l); + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + long __l; + + const __num_get_type& __ng =3D __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |=3D ios_base::failbit; + __n =3D __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |=3D ios_base::failbit; + __n =3D __gnu_cxx::__numeric_traits::__max; + } + else + __n =3D int(__l); + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + sentry __cerb(*this, false); + if (__cerb && __sbout) + { + if (true) + { + bool __ineof; + if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) + __err |=3D ios_base::failbit; + if (__ineof) + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::failbit); + ; + } + if (false) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbout) + __err |=3D 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 =3D traits_type::eof(); + int_type __c =3D __eof; + _M_gcount =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + __c =3D this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__c, __eof)) + _M_gcount =3D 1; + else + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |=3D 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 =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + const int_type __cb =3D this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__cb, traits_type::eof())) + { + _M_gcount =3D 1; + __c =3D traits_type::to_char_type(__cb); + } + else + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |=3D 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 =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + const int_type __idelim =3D traits_type::to_int_type(__delim); + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + int_type __c =3D __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ =3D traits_type::to_char_type(__c); + ++_M_gcount; + __c =3D __sb->snextc(); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s =3D char_type(); + if (!_M_gcount) + __err |=3D 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 =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + const int_type __idelim =3D traits_type::to_int_type(__delim); + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __this_sb =3D this->rdbuf(); + int_type __c =3D __this_sb->sgetc(); + char_type __c2 =3D traits_type::to_char_type(__c); + unsigned long long __gcount =3D 0; + + 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 =3D __this_sb->snextc(); + __c2 =3D traits_type::to_char_type(__c); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + + + if (__gcount <=3D __gnu_cxx::__numeric_traits::__max) + _M_gcount =3D __gcount; + else + _M_gcount =3D __gnu_cxx::__numeric_traits::__max; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |=3D 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 =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + const int_type __idelim =3D traits_type::to_int_type(__delim= ); + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + int_type __c =3D __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ =3D traits_type::to_char_type(__c); + __c =3D __sb->snextc(); + ++_M_gcount; + } + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + else + { + if (traits_type::eq_int_type(__c, __idelim)) + { + __sb->sbumpc(); + ++_M_gcount; + } + else + __err |=3D ios_base::failbit; + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s =3D char_type(); + if (!_M_gcount) + __err |=3D ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + + + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(void) + { + _M_gcount =3D 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + + if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) + __err |=3D ios_base::eofbit; + else + _M_gcount =3D 1; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + int_type __c =3D __sb->sgetc(); +# 545 "/usr/include/c++/13/bits/istream.tcc" 3 + bool __large_ignore =3D false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + ++_M_gcount; + __c =3D __sb->snextc(); + } + if (__n =3D=3D __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount =3D + __gnu_cxx::__numeric_traits::__min; + __large_ignore =3D true; + } + else + break; + } + + if (__n =3D=3D __gnu_cxx::__numeric_traits::__max) + { + if (__large_ignore) + _M_gcount =3D __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + } + else if (_M_gcount < __n) + { + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + int_type __c =3D __sb->sgetc(); + + + bool __large_ignore =3D false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + ++_M_gcount; + __c =3D __sb->snextc(); + } + if (__n =3D=3D __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + _M_gcount =3D + __gnu_cxx::__numeric_traits::__min; + __large_ignore =3D true; + } + else + break; + } + + if (__n =3D=3D __gnu_cxx::__numeric_traits::__max) + { + if (__large_ignore) + _M_gcount =3D __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + else + { + if (_M_gcount !=3D __n) + ++_M_gcount; + __sb->sbumpc(); + } + } + else if (_M_gcount < __n) + { + if (traits_type::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + else + { + ++_M_gcount; + __sb->sbumpc(); + } + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D traits_type::eof(); + _M_gcount =3D 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + __c =3D this->rdbuf()->sgetc(); + if (traits_type::eq_int_type(__c, traits_type::eof())) + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + _M_gcount =3D this->rdbuf()->sgetn(__s, __n); + if (_M_gcount !=3D __n) + __err |=3D (ios_base::eofbit | ios_base::failbit); + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + + const streamsize __num =3D this->rdbuf()->in_avail(); + if (__num > 0) + _M_gcount =3D this->rdbuf()->sgetn(__s, std::min(__num, __n)); + else if (__num =3D=3D -1) + __err |=3D ios_base::eofbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) + __err |=3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + const int_type __eof =3D traits_type::eof(); + __streambuf_type* __sb =3D this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sungetc(), __eof)) + __err |=3D ios_base::badbit; + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + int + basic_istream<_CharT, _Traits>:: + sync(void) + { + + + int __ret =3D -1; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + __streambuf_type* __sb =3D this->rdbuf(); + if (__sb) + { + if (__sb->pubsync() =3D=3D -1) + __err |=3D ios_base::badbit; + else + __ret =3D 0; + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D pos_type(-1); + sentry __cerb(*this, true); + if (__cerb) + { + if (true) + { + if (!this->fail()) + __ret =3D this->rdbuf()->pubseekoff(0, ios_base::cur, + ios_base::in); + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + if (!this->fail()) + { + + const pos_type __p =3D this->rdbuf()->pubseekpos(__pos, + ios_base::in); + + + if (__p =3D=3D pos_type(off_type(-1))) + __err |=3D ios_base::failbit; + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + if (!this->fail()) + { + + const pos_type __p =3D this->rdbuf()->pubseekoff(__off, __dir, + ios_base::in); + + + if (__p =3D=3D pos_type(off_type(-1))) + __err |=3D ios_base::failbit; + } + } + if (false) + { + this->_M_setstate(ios_base::badbit); + ; + } + if (false) + { 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 =3D ios_base::goodbit; + if (true) + { + const __int_type __cb =3D __in.rdbuf()->sbumpc(); + if (!_Traits::eq_int_type(__cb, _Traits::eof())) + __c =3D _Traits::to_char_type(__cb); + else + __err |=3D (ios_base::eofbit | ios_base::failbit); + } + if (false) + { + __in._M_setstate(ios_base::badbit); + ; + } + if (false) + { __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 =3D 0; + ios_base::iostate __err =3D ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + if (true) + { + + streamsize __width =3D __in.width(); + if (0 < __width && __width < __num) + __num =3D __width; + + const __ctype_type& __ct =3D use_facet<__ctype_type>(__in.getloc()); + + const int_type __eof =3D _Traits::eof(); + __streambuf_type* __sb =3D __in.rdbuf(); + int_type __c =3D __sb->sgetc(); + + while (__extracted < __num - 1 + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(ctype_base::space, + _Traits::to_char_type(__c))) + { + *__s++ =3D _Traits::to_char_type(__c); + ++__extracted; + __c =3D __sb->snextc(); + } + + if (__extracted < __num - 1 + && _Traits::eq_int_type(__c, __eof)) + __err |=3D ios_base::eofbit; + + + + *__s =3D char_type(); + __in.width(0); + } + if (false) + { + __in._M_setstate(ios_base::badbit); + ; + } + if (false) + { __in._M_setstate(ios_base::badbit); } + } + if (!__extracted) + __err |=3D 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 =3D ios_base::goodbit; + if (true) + { + const __ctype_type& __ct =3D use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof =3D _Traits::eof(); + __streambuf_type* __sb =3D __in.rdbuf(); + __int_type __c =3D __sb->sgetc(); + + while (true) + { + if (_Traits::eq_int_type(__c, __eof)) + { + __err =3D ios_base::eofbit; + break; + } + if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) + break; + __c =3D __sb->snextc(); + } + } + if (false) + { + __in._M_setstate(ios_base::badbit); + ; + } + if (false) + { + __in._M_setstate(ios_base::badbit); + } + if (__err) + __in.setstate(__err); + } + return __in; + } + + + + + 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&); + + extern template istream& istream::_M_extract(long long&); + extern template istream& istream::_M_extract(unsigned long long&); + + 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; + + + + +} +# 1107 "/usr/include/c++/13/istream" 2 3 +# 41 "/usr/include/c++/13/sstream" 2 3 +# 55 "/usr/include/c++/13/sstream" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { +# 78 "/usr/include/c++/13/sstream" 3 + template + class basic_stringbuf : public basic_streambuf<_CharT, _Traits> + { + struct __xfer_bufptrs; + + + using allocator_traits =3D std::allocator_traits<_Alloc>; + using _Noexcept_swap + =3D __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: +# 121 "/usr/include/c++/13/sstream" 3 + basic_stringbuf() + : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_stri= ng() + { } +# 132 "/usr/include/c++/13/sstream" 3 + explicit + basic_stringbuf(ios_base::openmode __mode) + : __streambuf_type(), _M_mode(__mode), _M_string() + { } +# 145 "/usr/include/c++/13/sstream" 3 + explicit + basic_stringbuf(const __string_type& __str, + ios_base::openmode __mode =3D 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&) =3D 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= ); } +# 209 "/usr/include/c++/13/sstream" 3 + basic_stringbuf& + operator=3D(const basic_stringbuf&) =3D delete; + + basic_stringbuf& + operator=3D(basic_stringbuf&& __rhs) + { + __xfer_bufptrs __st{__rhs, this}; + const __streambuf_type& __base =3D __rhs; + __streambuf_type::operator=3D(__base); + this->pubimbue(__rhs.getloc()); + _M_mode =3D __rhs._M_mode; + _M_string =3D 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 =3D __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); + } +# 248 "/usr/include/c++/13/sstream" 3 + __string_type + str() const + { + __string_type __ret(_M_string.get_allocator()); + if (char_type* __hi =3D _M_high_mark()) + __ret.assign(this->pbase(), __hi); + else + __ret =3D _M_string; + return __ret; + } +# 304 "/usr/include/c++/13/sstream" 3 + void + str(const __string_type& __s) + { + + + _M_string.assign(__s.data(), __s.size()); + _M_stringbuf_init(_M_mode); + } +# 333 "/usr/include/c++/13/sstream" 3 + protected: + + void + _M_stringbuf_init(ios_base::openmode __mode) + { + _M_mode =3D __mode; + __size_type __len =3D 0; + if (_M_mode & (ios_base::ate | ios_base::app)) + __len =3D _M_string.size(); + _M_sync(const_cast(_M_string.data()), 0, __len); + } + + virtual streamsize + showmanyc() + { + streamsize __ret =3D -1; + if (_M_mode & ios_base::in) + { + _M_update_egptr(); + __ret =3D this->egptr() - this->gptr(); + } + return __ret; + } + + virtual int_type + underflow(); + + virtual int_type + pbackfail(int_type __c =3D traits_type::eof()); + + virtual int_type + overflow(int_type __c =3D traits_type::eof()); +# 377 "/usr/include/c++/13/sstream" 3 + virtual __streambuf_type* + setbuf(char_type* __s, streamsize __n) + { + if (__s && __n >=3D 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 =3D ios_base::in | ios_base::out); + + virtual pos_type + seekpos(pos_type __sp, + ios_base::openmode __mode =3D 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 =3D this->pptr()) + { + char_type* __egptr =3D 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 =3D this->pptr()) + { + char_type* __egptr =3D 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 =3D __from._M_string.data(); + const _CharT* __end =3D nullptr; + if (__from.eback()) + { + _M_goff[0] =3D __from.eback() - __str; + _M_goff[1] =3D __from.gptr() - __str; + _M_goff[2] =3D __from.egptr() - __str; + __end =3D __from.egptr(); + } + if (__from.pbase()) + { + _M_poff[0] =3D __from.pbase() - __str; + _M_poff[1] =3D __from.pptr() - __from.pbase(); + _M_poff[2] =3D __from.epptr() - __str; + if (!__end || __from.pptr() > __end) + __end =3D __from.pptr(); + } + + + if (__end) + { + + + auto& __mut_from =3D const_cast(__from); + __mut_from._M_string._M_length(__end - __str); + } + } + + ~__xfer_bufptrs() + { + char_type* __str =3D const_cast(_M_to->_M_string.data()); + if (_M_goff[0] !=3D -1) + _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]); + if (_M_poff[0] !=3D -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]; + }; +# 513 "/usr/include/c++/13/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)) + { } +# 528 "/usr/include/c++/13/sstream" 3 + }; +# 546 "/usr/include/c++/13/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: +# 580 "/usr/include/c++/13/sstream" 3 + basic_istringstream() + : __istream_type(), _M_stringbuf(ios_base::in) + { this->init(&_M_stringbuf); } +# 596 "/usr/include/c++/13/sstream" 3 + explicit + basic_istringstream(ios_base::openmode __mode) + : __istream_type(), _M_stringbuf(__mode | ios_base::in) + { this->init(&_M_stringbuf); } +# 614 "/usr/include/c++/13/sstream" 3 + explicit + basic_istringstream(const __string_type& __str, + ios_base::openmode __mode =3D ios_base::in) + : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) + { this->init(&_M_stringbuf); } + + + + + + + + ~basic_istringstream() + { } + + + basic_istringstream(const basic_istringstream&) =3D delete; + + basic_istringstream(basic_istringstream&& __rhs) + : __istream_type(std::move(__rhs)), + _M_stringbuf(std::move(__rhs._M_stringbuf)) + { __istream_type::set_rdbuf(&_M_stringbuf); } +# 671 "/usr/include/c++/13/sstream" 3 + basic_istringstream& + operator=3D(const basic_istringstream&) =3D delete; + + basic_istringstream& + operator=3D(basic_istringstream&& __rhs) + { + __istream_type::operator=3D(std::move(__rhs)); + _M_stringbuf =3D std::move(__rhs._M_stringbuf); + return *this; + } + + void + swap(basic_istringstream& __rhs) + { + __istream_type::swap(__rhs); + _M_stringbuf.swap(__rhs._M_stringbuf); + } +# 697 "/usr/include/c++/13/sstream" 3 + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + + + + + __string_type + str() const + { return _M_stringbuf.str(); } +# 735 "/usr/include/c++/13/sstream" 3 + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } +# 752 "/usr/include/c++/13/sstream" 3 + }; +# 770 "/usr/include/c++/13/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: +# 804 "/usr/include/c++/13/sstream" 3 + basic_ostringstream() + : __ostream_type(), _M_stringbuf(ios_base::out) + { this->init(&_M_stringbuf); } +# 820 "/usr/include/c++/13/sstream" 3 + explicit + basic_ostringstream(ios_base::openmode __mode) + : __ostream_type(), _M_stringbuf(__mode | ios_base::out) + { this->init(&_M_stringbuf); } +# 838 "/usr/include/c++/13/sstream" 3 + explicit + basic_ostringstream(const __string_type& __str, + ios_base::openmode __mode =3D ios_base::out) + : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) + { this->init(&_M_stringbuf); } + + + + + + + + ~basic_ostringstream() + { } + + + basic_ostringstream(const basic_ostringstream&) =3D delete; + + basic_ostringstream(basic_ostringstream&& __rhs) + : __ostream_type(std::move(__rhs)), + _M_stringbuf(std::move(__rhs._M_stringbuf)) + { __ostream_type::set_rdbuf(&_M_stringbuf); } +# 895 "/usr/include/c++/13/sstream" 3 + basic_ostringstream& + operator=3D(const basic_ostringstream&) =3D delete; + + basic_ostringstream& + operator=3D(basic_ostringstream&& __rhs) + { + __ostream_type::operator=3D(std::move(__rhs)); + _M_stringbuf =3D std::move(__rhs._M_stringbuf); + return *this; + } + + void + swap(basic_ostringstream& __rhs) + { + __ostream_type::swap(__rhs); + _M_stringbuf.swap(__rhs._M_stringbuf); + } +# 921 "/usr/include/c++/13/sstream" 3 + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + + + + + __string_type + str() const + { return _M_stringbuf.str(); } +# 959 "/usr/include/c++/13/sstream" 3 + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } +# 976 "/usr/include/c++/13/sstream" 3 + }; +# 994 "/usr/include/c++/13/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: +# 1028 "/usr/include/c++/13/sstream" 3 + basic_stringstream() + : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in) + { this->init(&_M_stringbuf); } +# 1042 "/usr/include/c++/13/sstream" 3 + explicit + basic_stringstream(ios_base::openmode __m) + : __iostream_type(), _M_stringbuf(__m) + { this->init(&_M_stringbuf); } +# 1058 "/usr/include/c++/13/sstream" 3 + explicit + basic_stringstream(const __string_type& __str, + ios_base::openmode __m =3D ios_base::out | ios_base::in) + : __iostream_type(), _M_stringbuf(__str, __m) + { this->init(&_M_stringbuf); } + + + + + + + + ~basic_stringstream() + { } + + + basic_stringstream(const basic_stringstream&) =3D delete; + + basic_stringstream(basic_stringstream&& __rhs) + : __iostream_type(std::move(__rhs)), + _M_stringbuf(std::move(__rhs._M_stringbuf)) + { __iostream_type::set_rdbuf(&_M_stringbuf); } +# 1117 "/usr/include/c++/13/sstream" 3 + basic_stringstream& + operator=3D(const basic_stringstream&) =3D delete; + + basic_stringstream& + operator=3D(basic_stringstream&& __rhs) + { + __iostream_type::operator=3D(std::move(__rhs)); + _M_stringbuf =3D std::move(__rhs._M_stringbuf); + return *this; + } + + void + swap(basic_stringstream& __rhs) + { + __iostream_type::swap(__rhs); + _M_stringbuf.swap(__rhs._M_stringbuf); + } +# 1143 "/usr/include/c++/13/sstream" 3 + __stringbuf_type* + rdbuf() const + { return const_cast<__stringbuf_type*>(&_M_stringbuf); } + + + + + + __string_type + str() const + { return _M_stringbuf.str(); } +# 1181 "/usr/include/c++/13/sstream" 3 + void + str(const __string_type& __s) + { _M_stringbuf.str(__s); } +# 1198 "/usr/include/c++/13/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++/13/bits/sstream.tcc" 1 3 +# 37 "/usr/include/c++/13/bits/sstream.tcc" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/sstream.tcc" 3 + +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 =3D traits_type::eof(); + if (this->eback() < this->gptr()) + { + + + const bool __testeof =3D traits_type::eq_int_type(__c, __ret); + if (!__testeof) + { + const bool __testeq =3D traits_type::eq(traits_type:: + to_char_type(__c), + this->gptr()[-1]); + const bool __testout =3D this->_M_mode & ios_base::out; + if (__testeq || __testout) + { + this->gbump(-1); + if (!__testeq) + *this->gptr() =3D traits_type::to_char_type(__c); + __ret =3D __c; + } + } + else + { + this->gbump(-1); + __ret =3D 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 =3D this->_M_mode & ios_base::out; + if (__builtin_expect(!__testout, false)) + return traits_type::eof(); + + const bool __testeof =3D traits_type::eq_int_type(__c, traits_type::= eof()); + if (__builtin_expect(__testeof, false)) + return traits_type::not_eof(__c); + + const __size_type __capacity =3D _M_string.capacity(); + + + if (size_t(this->epptr() - this->pbase()) < __capacity) + { + + char_type* __base =3D const_cast(_M_string.data()); + _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase()); + if (_M_mode & ios_base::in) + { + const __size_type __nget =3D this->gptr() - this->eback(); + const __size_type __eget =3D this->egptr() - this->eback(); + this->setg(__base, __base + __nget, __base + __eget + 1); + } + *this->pptr() =3D traits_type::to_char_type(__c); + this->pbump(1); + return __c; + } + + + const __size_type __max_size =3D _M_string.max_size(); + const bool __testput =3D this->pptr() < this->epptr(); + if (__builtin_expect(!__testput && __capacity =3D=3D __max_size, fal= se)) + return traits_type::eof(); + + + + const char_type __conv =3D traits_type::to_char_type(__c); + if (!__testput) + { +# 129 "/usr/include/c++/13/bits/sstream.tcc" 3 + const __size_type __opt_len =3D std::max(__size_type(2 * __capacity), + __size_type(512)); + const __size_type __len =3D 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() =3D __conv; + this->pbump(1); + return __c; + } + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + underflow() + { + int_type __ret =3D traits_type::eof(); + const bool __testin =3D this->_M_mode & ios_base::in; + if (__testin) + { + + _M_update_egptr(); + + if (this->gptr() < this->egptr()) + __ret =3D 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 =3D pos_type(off_type(-1)); + bool __testin =3D (ios_base::in & this->_M_mode & __mode) !=3D 0; + bool __testout =3D (ios_base::out & this->_M_mode & __mode) !=3D 0; + const bool __testboth =3D __testin && __testout && __way !=3D ios_ba= se::cur; + __testin &=3D !(__mode & ios_base::out); + __testout &=3D !(__mode & ios_base::in); + + + + const char_type* __beg =3D __testin ? this->eback() : this->pbase(); + if ((__beg || !__off) && (__testin || __testout || __testboth)) + { + _M_update_egptr(); + + off_type __newoffi =3D __off; + off_type __newoffo =3D __newoffi; + if (__way =3D=3D ios_base::cur) + { + __newoffi +=3D this->gptr() - __beg; + __newoffo +=3D this->pptr() - __beg; + } + else if (__way =3D=3D ios_base::end) + __newoffo =3D __newoffi +=3D this->egptr() - __beg; + + if ((__testin || __testboth) + && __newoffi >=3D 0 + && this->egptr() - __beg >=3D __newoffi) + { + this->setg(this->eback(), this->eback() + __newoffi, + this->egptr()); + __ret =3D pos_type(__newoffi); + } + if ((__testout || __testboth) + && __newoffo >=3D 0 + && this->egptr() - __beg >=3D __newoffo) + { + _M_pbump(this->pbase(), this->epptr(), __newoffo); + __ret =3D 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 =3D pos_type(off_type(-1)); + const bool __testin =3D (ios_base::in & this->_M_mode & __mode) !=3D= 0; + const bool __testout =3D (ios_base::out & this->_M_mode & __mode) != =3D 0; + + const char_type* __beg =3D __testin ? this->eback() : this->pbase(); + if ((__beg || !off_type(__sp)) && (__testin || __testout)) + { + _M_update_egptr(); + + const off_type __pos(__sp); + const bool __testpos =3D (0 <=3D __pos + && __pos <=3D 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 =3D __sp; + } + } + return __ret; + } + + template + void + basic_stringbuf<_CharT, _Traits, _Alloc>:: + _M_sync(char_type* __base, __size_type __i, __size_type __o) + { + const bool __testin =3D _M_mode & ios_base::in; + const bool __testout =3D _M_mode & ios_base::out; + char_type* __endg =3D __base + _M_string.size(); + char_type* __endp =3D __base + _M_string.capacity(); + + if (__base !=3D _M_string.data()) + { + + __endg +=3D __i; + __i =3D 0; + __endp =3D __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 -=3D __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; + + + + +} +# 1239 "/usr/include/c++/13/sstream" 2 3 +# 54 "/usr/include/gtest/gtest-message.h" 2 3 4 + +# 1 "/usr/include/gtest/internal/gtest-port.h" 1 3 4 +# 259 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 260 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 + +# 1 "/usr/include/c++/13/stdlib.h" 1 3 4 +# 36 "/usr/include/c++/13/stdlib.h" 3 4 +# 1 "/usr/include/c++/13/cstdlib" 1 3 4 +# 39 "/usr/include/c++/13/cstdlib" 3 4 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cstdlib" 3 +# 37 "/usr/include/c++/13/stdlib.h" 2 3 4 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 262 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 + + +# 1 "/usr/include/c++/13/cerrno" 1 3 4 +# 39 "/usr/include/c++/13/cerrno" 3 4 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cerrno" 3 +# 265 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 + +# 1 "/usr/include/c++/13/cstdint" 1 3 4 +# 32 "/usr/include/c++/13/cstdint" 3 4 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/cstdint" 3 +# 48 "/usr/include/c++/13/cstdint" 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; +# 142 "/usr/include/c++/13/cstdint" 3 +} +# 267 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 1 "/usr/include/c++/13/iostream" 1 3 4 +# 36 "/usr/include/c++/13/iostream" 3 4 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/iostream" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 62 "/usr/include/c++/13/iostream" 3 + extern istream cin; + extern ostream cout; + extern ostream cerr; + extern ostream clog; + + + extern wistream wcin; + extern wostream wcout; + extern wostream wcerr; + extern wostream wclog; +# 82 "/usr/include/c++/13/iostream" 3 + +} +# 268 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 + +# 1 "/usr/include/c++/13/locale" 1 3 4 +# 36 "/usr/include/c++/13/locale" 3 4 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/locale" 3 + + + + + + +# 1 "/usr/include/c++/13/bits/locale_facets_nonio.h" 1 3 +# 37 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 +=20=20=20=20=20=20=20 +# 38 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + +# 1 "/usr/include/c++/13/ctime" 1 3 +# 39 "/usr/include/c++/13/ctime" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/ctime" 3 +# 58 "/usr/include/c++/13/ctime" 3 +namespace std +{ + using ::clock_t; + using ::time_t; + using ::tm; + + using ::clock; + using ::difftime; + using ::mktime; + using ::time; + using ::asctime; + using ::ctime; + using ::gmtime; + using ::localtime; + using ::strftime; +} + + + +namespace std +{ + using ::timespec; + using ::timespec_get; +} +# 40 "/usr/include/c++/13/bits/locale_facets_nonio.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 52 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + class time_base + { + public: + enum dateorder { no_order, dmy, mdy, ymd, ydm }; + }; + + template + struct __timepunct_cache : public locale::facet + { + + static const _CharT* _S_timezones[14]; + + const _CharT* _M_date_format; + const _CharT* _M_date_era_format; + const _CharT* _M_time_format; + const _CharT* _M_time_era_format; + const _CharT* _M_date_time_format; + const _CharT* _M_date_time_era_format; + const _CharT* _M_am; + const _CharT* _M_pm; + const _CharT* _M_am_pm_format; + + + const _CharT* _M_day1; + const _CharT* _M_day2; + const _CharT* _M_day3; + const _CharT* _M_day4; + const _CharT* _M_day5; + const _CharT* _M_day6; + const _CharT* _M_day7; + + + const _CharT* _M_aday1; + const _CharT* _M_aday2; + const _CharT* _M_aday3; + const _CharT* _M_aday4; + const _CharT* _M_aday5; + const _CharT* _M_aday6; + const _CharT* _M_aday7; + + + const _CharT* _M_month01; + const _CharT* _M_month02; + const _CharT* _M_month03; + const _CharT* _M_month04; + const _CharT* _M_month05; + const _CharT* _M_month06; + const _CharT* _M_month07; + const _CharT* _M_month08; + const _CharT* _M_month09; + const _CharT* _M_month10; + const _CharT* _M_month11; + const _CharT* _M_month12; + + + const _CharT* _M_amonth01; + const _CharT* _M_amonth02; + const _CharT* _M_amonth03; + const _CharT* _M_amonth04; + const _CharT* _M_amonth05; + const _CharT* _M_amonth06; + const _CharT* _M_amonth07; + const _CharT* _M_amonth08; + const _CharT* _M_amonth09; + const _CharT* _M_amonth10; + const _CharT* _M_amonth11; + const _CharT* _M_amonth12; + + bool _M_allocated; + + __timepunct_cache(size_t __refs =3D 0) : facet(__refs), + _M_date_format(0), _M_date_era_format(0), _M_time_format(0), + _M_time_era_format(0), _M_date_time_format(0), + _M_date_time_era_format(0), _M_am(0), _M_pm(0), + _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0), + _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0), + _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0), + _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0), + _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0), + _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0), + _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0), + _M_amonth02(0), _M_amonth03(0), _M_amonth04(0), + _M_amonth05(0), _M_amonth06(0), _M_amonth07(0), + _M_amonth08(0), _M_amonth09(0), _M_amonth10(0), + _M_amonth11(0), _M_amonth12(0), _M_allocated(false) + { } + + ~__timepunct_cache(); + + private: + __timepunct_cache& + operator=3D(const __timepunct_cache&); + + explicit + __timepunct_cache(const __timepunct_cache&); + }; + + template + __timepunct_cache<_CharT>::~__timepunct_cache() + { + if (_M_allocated) + { + + } + } + + + template<> + const char* + __timepunct_cache::_S_timezones[14]; + + + template<> + const wchar_t* + __timepunct_cache::_S_timezones[14]; + + + + template + const _CharT* __timepunct_cache<_CharT>::_S_timezones[14]; + + template + class __timepunct : public locale::facet + { + public: + + typedef _CharT __char_type; + typedef __timepunct_cache<_CharT> __cache_type; + + protected: + __cache_type* _M_data; + __c_locale _M_c_locale_timepunct; + const char* _M_name_timepunct; + + public: + + static locale::id id; + + explicit + __timepunct(size_t __refs =3D 0); + + explicit + __timepunct(__cache_type* __cache, size_t __refs =3D 0); +# 206 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + __timepunct(__c_locale __cloc, const char* __s, size_t __refs =3D 0); + + + + void + _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format, + const tm* __tm) const throw (); + + void + _M_date_formats(const _CharT** __date) const + { + + __date[0] =3D _M_data->_M_date_format; + __date[1] =3D _M_data->_M_date_era_format; + } + + void + _M_time_formats(const _CharT** __time) const + { + + __time[0] =3D _M_data->_M_time_format; + __time[1] =3D _M_data->_M_time_era_format; + } + + void + _M_date_time_formats(const _CharT** __dt) const + { + + __dt[0] =3D _M_data->_M_date_time_format; + __dt[1] =3D _M_data->_M_date_time_era_format; + } + + + void + _M_am_pm_format(const _CharT*) const + { } + + + void + _M_am_pm_format(const _CharT** __ampm_format) const + { + __ampm_format[0] =3D _M_data->_M_am_pm_format; + } + + void + _M_am_pm(const _CharT** __ampm) const + { + __ampm[0] =3D _M_data->_M_am; + __ampm[1] =3D _M_data->_M_pm; + } + + void + _M_days(const _CharT** __days) const + { + __days[0] =3D _M_data->_M_day1; + __days[1] =3D _M_data->_M_day2; + __days[2] =3D _M_data->_M_day3; + __days[3] =3D _M_data->_M_day4; + __days[4] =3D _M_data->_M_day5; + __days[5] =3D _M_data->_M_day6; + __days[6] =3D _M_data->_M_day7; + } + + void + _M_days_abbreviated(const _CharT** __days) const + { + __days[0] =3D _M_data->_M_aday1; + __days[1] =3D _M_data->_M_aday2; + __days[2] =3D _M_data->_M_aday3; + __days[3] =3D _M_data->_M_aday4; + __days[4] =3D _M_data->_M_aday5; + __days[5] =3D _M_data->_M_aday6; + __days[6] =3D _M_data->_M_aday7; + } + + void + _M_months(const _CharT** __months) const + { + __months[0] =3D _M_data->_M_month01; + __months[1] =3D _M_data->_M_month02; + __months[2] =3D _M_data->_M_month03; + __months[3] =3D _M_data->_M_month04; + __months[4] =3D _M_data->_M_month05; + __months[5] =3D _M_data->_M_month06; + __months[6] =3D _M_data->_M_month07; + __months[7] =3D _M_data->_M_month08; + __months[8] =3D _M_data->_M_month09; + __months[9] =3D _M_data->_M_month10; + __months[10] =3D _M_data->_M_month11; + __months[11] =3D _M_data->_M_month12; + } + + void + _M_months_abbreviated(const _CharT** __months) const + { + __months[0] =3D _M_data->_M_amonth01; + __months[1] =3D _M_data->_M_amonth02; + __months[2] =3D _M_data->_M_amonth03; + __months[3] =3D _M_data->_M_amonth04; + __months[4] =3D _M_data->_M_amonth05; + __months[5] =3D _M_data->_M_amonth06; + __months[6] =3D _M_data->_M_amonth07; + __months[7] =3D _M_data->_M_amonth08; + __months[8] =3D _M_data->_M_amonth09; + __months[9] =3D _M_data->_M_amonth10; + __months[10] =3D _M_data->_M_amonth11; + __months[11] =3D _M_data->_M_amonth12; + } + + protected: + virtual + ~__timepunct(); + + + void + _M_initialize_timepunct(__c_locale __cloc =3D 0); + }; + + template + locale::id __timepunct<_CharT>::id; + + + template<> + void + __timepunct::_M_initialize_timepunct(__c_locale __cloc); + + template<> + void + __timepunct::_M_put(char*, size_t, const char*, const tm*) const= throw (); + + + template<> + void + __timepunct::_M_initialize_timepunct(__c_locale __cloc); + + template<> + void + __timepunct::_M_put(wchar_t*, size_t, const wchar_t*, + const tm*) const throw (); + + + +} + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/time_members.h" 1 3 +# 37 "/usr/include/riscv64-linux-gnu/c++/13/bits/time_members.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + __timepunct<_CharT>::__timepunct(size_t __refs) + : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), + _M_name_timepunct(_S_get_c_name()) + { _M_initialize_timepunct(); } + + template + __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs) + : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0), + _M_name_timepunct(_S_get_c_name()) + { _M_initialize_timepunct(); } + + template + __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s, + size_t __refs) + : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), + _M_name_timepunct(0) + { + if (__builtin_strcmp(__s, _S_get_c_name()) !=3D 0) + { + const size_t __len =3D __builtin_strlen(__s) + 1; + char* __tmp =3D new char[__len]; + __builtin_memcpy(__tmp, __s, __len); + _M_name_timepunct =3D __tmp; + } + else + _M_name_timepunct =3D _S_get_c_name(); + + if (true) + { _M_initialize_timepunct(__cloc); } + if (false) + { + if (_M_name_timepunct !=3D _S_get_c_name()) + delete [] _M_name_timepunct; + ; + } + } + + template + __timepunct<_CharT>::~__timepunct() + { + if (_M_name_timepunct !=3D _S_get_c_name()) + delete [] _M_name_timepunct; + delete _M_data; + _S_destroy_c_locale(_M_c_locale_timepunct); + } + + +} +# 353 "/usr/include/c++/13/bits/locale_facets_nonio.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __time_get_state + { + + void + _M_finalize_state(tm* __tm); + + unsigned int _M_have_I : 1; + unsigned int _M_have_wday : 1; + unsigned int _M_have_yday : 1; + unsigned int _M_have_mon : 1; + unsigned int _M_have_mday : 1; + unsigned int _M_have_uweek : 1; + unsigned int _M_have_wweek : 1; + unsigned int _M_have_century : 1; + unsigned int _M_is_pm : 1; + unsigned int _M_want_century : 1; + unsigned int _M_want_xday : 1; + unsigned int _M_pad1 : 5; + unsigned int _M_week_no : 6; + unsigned int _M_pad2 : 10; + int _M_century; + int _M_pad3; + }; + +namespace __cxx11 { +# 397 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class time_get : public locale::facet, public time_base + { + public: + + + + typedef _CharT char_type; + typedef _InIter iter_type; + + + + static locale::id id; +# 418 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + time_get(size_t __refs =3D 0) + : facet (__refs) { } +# 435 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + dateorder + date_order() const + { return this->do_date_order(); } +# 459 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_time(__beg, __end, __io, __err, __tm); } +# 484 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_date(__beg, __end, __io, __err, __tm); } +# 512 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get_weekday(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_weekday(__beg, __end, __io, __err, __tm); } +# 541 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get_monthname(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_monthname(__beg, __end, __io, __err, __tm); } +# 567 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_year(__beg, __end, __io, __err, __tm); } +# 588 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + inline + iter_type get(iter_type __s, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, char __format, + char __modifier =3D 0) const + { + return this->do_get(__s, __end, __io, __err, __tm, __format, + __modifier); + } +# 615 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type get(iter_type __s, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, const char_type* _= _fmt, + const char_type* __fmtend) const; + + + protected: + + virtual + ~time_get() { } +# 635 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual dateorder + do_date_order() const; +# 653 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; +# 672 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; +# 691 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get_weekday(iter_type __beg, iter_type __end, ios_base&, + ios_base::iostate& __err, tm* __tm) const; +# 710 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get_monthname(iter_type __beg, iter_type __end, ios_base&, + ios_base::iostate& __err, tm* __tm) const; +# 729 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; +# 752 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual + + iter_type + do_get(iter_type __s, iter_type __end, ios_base& __f, + ios_base::iostate& __err, tm* __tm, + char __format, char __modifier) const; + + + + iter_type + _M_extract_num(iter_type __beg, iter_type __end, int& __member, + int __min, int __max, size_t __len, + ios_base& __io, ios_base::iostate& __err) const; + + + iter_type + _M_extract_name(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const; + + + iter_type + _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __me= mber, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const; + + + iter_type + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __= io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format) const; + + + + iter_type + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __= io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format, + __time_get_state &__state) const; + }; + + template + locale::id time_get<_CharT, _InIter>::id; + + + template + class time_get_byname : public time_get<_CharT, _InIter> + { + public: + + typedef _CharT char_type; + typedef _InIter iter_type; + + explicit + time_get_byname(const char*, size_t __refs =3D 0) + : time_get<_CharT, _InIter>(__refs) { } + + + explicit + time_get_byname(const string& __s, size_t __refs =3D 0) + : time_get_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~time_get_byname() { } + }; + +} +# 834 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class time_put : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _OutIter iter_type; + + + + static locale::id id; +# 855 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + time_put(size_t __refs =3D 0) + : facet(__refs) { } +# 874 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, + const _CharT* __beg, const _CharT* __end) const; +# 894 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + const tm* __tm, char __format, char __mod =3D 0) const + { return this->do_put(__s, __io, __fill, __tm, __format, __mod); } + + protected: + + virtual + ~time_put() + { } +# 921 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __= tm, + char __format, char __mod) const; + }; + + template + locale::id time_put<_CharT, _OutIter>::id; + + + template + class time_put_byname : public time_put<_CharT, _OutIter> + { + public: + + typedef _CharT char_type; + typedef _OutIter iter_type; + + explicit + time_put_byname(const char*, size_t __refs =3D 0) + : time_put<_CharT, _OutIter>(__refs) + { } + + + explicit + time_put_byname(const string& __s, size_t __refs =3D 0) + : time_put_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~time_put_byname() { } + }; +# 966 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + class money_base + { + public: + enum part { none, space, symbol, sign, value }; + struct pattern { char field[4]; }; + + static const pattern _S_default_pattern; + + enum + { + _S_minus, + _S_zero, + _S_end =3D 11 + }; + + + + static const char* _S_atoms; + + + + __attribute__ ((__const__)) static pattern + _S_construct_pattern(char __precedes, char __space, char __posn) throw= (); + }; + + template + struct __moneypunct_cache : public locale::facet + { + const char* _M_grouping; + size_t _M_grouping_size; + bool _M_use_grouping; + _CharT _M_decimal_point; + _CharT _M_thousands_sep; + const _CharT* _M_curr_symbol; + size_t _M_curr_symbol_size; + const _CharT* _M_positive_sign; + size_t _M_positive_sign_size; + const _CharT* _M_negative_sign; + size_t _M_negative_sign_size; + int _M_frac_digits; + money_base::pattern _M_pos_format; + money_base::pattern _M_neg_format; + + + + + _CharT _M_atoms[money_base::_S_end]; + + bool _M_allocated; + + __moneypunct_cache(size_t __refs =3D 0) : facet(__refs), + _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false), + _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), + _M_curr_symbol(0), _M_curr_symbol_size(0), + _M_positive_sign(0), _M_positive_sign_size(0), + _M_negative_sign(0), _M_negative_sign_size(0), + _M_frac_digits(0), + _M_pos_format(money_base::pattern()), + _M_neg_format(money_base::pattern()), _M_allocated(false) + { } + + ~__moneypunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __moneypunct_cache& + operator=3D(const __moneypunct_cache&); + + explicit + __moneypunct_cache(const __moneypunct_cache&); + }; + + template + __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache() + { + if (_M_allocated) + { + delete [] _M_grouping; + delete [] _M_curr_symbol; + delete [] _M_positive_sign; + delete [] _M_negative_sign; + } + } + +namespace __cxx11 { +# 1061 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class moneypunct : public locale::facet, public money_base + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + private: + __cache_type* _M_data; + + public: + + + static const bool intl =3D _Intl; + + static locale::id id; +# 1090 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + moneypunct(size_t __refs =3D 0) + : facet(__refs), _M_data(0) + { _M_initialize_moneypunct(); } +# 1103 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + moneypunct(__cache_type* __cache, size_t __refs =3D 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_moneypunct(); } +# 1118 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + moneypunct(__c_locale __cloc, const char* __s, size_t __refs =3D 0) + : facet(__refs), _M_data(0) + { _M_initialize_moneypunct(__cloc, __s); } +# 1132 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + char_type + decimal_point() const + { return this->do_decimal_point(); } +# 1145 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + char_type + thousands_sep() const + { return this->do_thousands_sep(); } +# 1175 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + string + grouping() const + { return this->do_grouping(); } +# 1188 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + string_type + curr_symbol() const + { return this->do_curr_symbol(); } +# 1205 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + string_type + positive_sign() const + { return this->do_positive_sign(); } +# 1222 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + string_type + negative_sign() const + { return this->do_negative_sign(); } +# 1238 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + int + frac_digits() const + { return this->do_frac_digits(); } +# 1274 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + pattern + pos_format() const + { return this->do_pos_format(); } + + pattern + neg_format() const + { return this->do_neg_format(); } + + + protected: + + virtual + ~moneypunct(); +# 1296 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } +# 1308 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } +# 1321 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual string + do_grouping() const + { return _M_data->_M_grouping; } +# 1334 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual string_type + do_curr_symbol() const + { return _M_data->_M_curr_symbol; } +# 1347 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual string_type + do_positive_sign() const + { return _M_data->_M_positive_sign; } +# 1360 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual string_type + do_negative_sign() const + { return _M_data->_M_negative_sign; } +# 1374 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual int + do_frac_digits() const + { return _M_data->_M_frac_digits; } +# 1388 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual pattern + do_pos_format() const + { return _M_data->_M_pos_format; } +# 1402 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual pattern + do_neg_format() const + { return _M_data->_M_neg_format; } + + + void + _M_initialize_moneypunct(__c_locale __cloc =3D 0, + const char* __name =3D 0); + }; + + template + locale::id moneypunct<_CharT, _Intl>::id; + + template + const bool moneypunct<_CharT, _Intl>::intl; + + template<> + moneypunct::~moneypunct(); + + template<> + moneypunct::~moneypunct(); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, const cha= r*); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, const ch= ar*); + + + template<> + moneypunct::~moneypunct(); + + template<> + moneypunct::~moneypunct(); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, + const char*); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, + const char*); + + + + template + class moneypunct_byname : public moneypunct<_CharT, _Intl> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + static const bool intl =3D _Intl; + + explicit + moneypunct_byname(const char* __s, size_t __refs =3D 0) + : moneypunct<_CharT, _Intl>(__refs) + { + if (__builtin_strcmp(__s, "C") !=3D 0 + && __builtin_strcmp(__s, "POSIX") !=3D 0) + { + __c_locale __tmp; + this->_S_create_c_locale(__tmp, __s); + this->_M_initialize_moneypunct(__tmp); + this->_S_destroy_c_locale(__tmp); + } + } + + + explicit + moneypunct_byname(const string& __s, size_t __refs =3D 0) + : moneypunct_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~moneypunct_byname() { } + }; + + template + const bool moneypunct_byname<_CharT, _Intl>::intl; + +} + +namespace __cxx11 { +# 1505 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class money_get : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _InIter iter_type; + typedef basic_string<_CharT> string_type; + + + + static locale::id id; +# 1527 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + money_get(size_t __refs =3D 0) : facet(__refs) { } +# 1557 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const + { return this->do_get(__s, __end, __intl, __io, __err, __units); } +# 1588 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const + { return this->do_get(__s, __end, __intl, __io, __err, __digits); } + + protected: + + virtual + ~money_get() { } +# 1612 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const; +# 1624 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const; +# 1644 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + iter_type + _M_extract(iter_type __s, iter_type __end, ios_base& __io, + ios_base::iostate& __err, string& __digits) const; + }; + + template + locale::id money_get<_CharT, _InIter>::id; +# 1666 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class money_put : public locale::facet + { + public: + + + typedef _CharT char_type; + typedef _OutIter iter_type; + typedef basic_string<_CharT> string_type; + + + + static locale::id id; +# 1687 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + money_put(size_t __refs =3D 0) : facet(__refs) { } +# 1707 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + put(iter_type __s, bool __intl, ios_base& __io, + char_type __fill, long double __units) const + { return this->do_put(__s, __intl, __io, __fill, __units); } +# 1730 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + iter_type + put(iter_type __s, bool __intl, ios_base& __io, + char_type __fill, const string_type& __digits) const + { return this->do_put(__s, __intl, __io, __fill, __digits); } + + protected: + + virtual + ~money_put() { } +# 1765 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + long double __units) const; +# 1789 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual iter_type + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + const string_type& __digits) const; +# 1809 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + iter_type + _M_insert(iter_type __s, ios_base& __io, char_type __fill, + const string_type& __digits) const; + }; + + template + locale::id money_put<_CharT, _OutIter>::id; + +} + + + + + + struct messages_base + { + typedef int catalog; + }; + +namespace __cxx11 { +# 1852 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + template + class messages : public locale::facet, public messages_base + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + + protected: + + + __c_locale _M_c_locale_messages; + const char* _M_name_messages; + + public: + + static locale::id id; +# 1880 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + messages(size_t __refs =3D 0); +# 1894 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + explicit + messages(__c_locale __cloc, const char* __s, size_t __refs =3D 0); +# 1907 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + catalog + open(const basic_string& __s, const locale& __loc) const + { return this->do_open(__s, __loc); } +# 1925 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + catalog + open(const basic_string&, const locale&, const char*) const; +# 1943 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + string_type + get(catalog __c, int __set, int __msgid, const string_type& __s) con= st + { return this->do_get(__c, __set, __msgid, __s); } +# 1954 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + void + close(catalog __c) const + { return this->do_close(__c); } + + protected: + + virtual + ~messages(); +# 1974 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual catalog + do_open(const basic_string&, const locale&) const; +# 1993 "/usr/include/c++/13/bits/locale_facets_nonio.h" 3 + virtual string_type + do_get(catalog, int, int, const string_type& __dfault) const; + + + + + + + virtual void + do_close(catalog) const; + + + char* + _M_convert_to_char(const string_type& __msg) const + { + + return reinterpret_cast(const_cast<_CharT*>(__msg.c_str())); + } + + + string_type + _M_convert_from_char(char*) const + { + + return string_type(); + } + }; + + template + locale::id messages<_CharT>::id; + + + template<> + string + messages::do_get(catalog, int, int, const string&) const; + + + template<> + wstring + messages::do_get(catalog, int, int, const wstring&) const; + + + + template + class messages_byname : public messages<_CharT> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + explicit + messages_byname(const char* __s, size_t __refs =3D 0); + + + explicit + messages_byname(const string& __s, size_t __refs =3D 0) + : messages_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~messages_byname() + { } + }; + +} + + +} + + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/messages_members.h" 1 3 +# 36 "/usr/include/riscv64-linux-gnu/c++/13/bits/messages_members.h" 3 +# 1 "/usr/include/libintl.h" 1 3 4 +# 34 "/usr/include/libintl.h" 3 4 +extern "C" { + + + + +extern char *gettext (const char *__msgid) + noexcept (true) __attribute__ ((__format_arg__ (1))); + + + +extern char *dgettext (const char *__domainname, const char *__msgid) + noexcept (true) __attribute__ ((__format_arg__ (2))); +extern char *__dgettext (const char *__domainname, const char *__msgid) + noexcept (true) __attribute__ ((__format_arg__ (2))); + + + +extern char *dcgettext (const char *__domainname, + const char *__msgid, int __category) + noexcept (true) __attribute__ ((__format_arg__ (2))); +extern char *__dcgettext (const char *__domainname, + const char *__msgid, int __category) + noexcept (true) __attribute__ ((__format_arg__ (2))); + + + + +extern char *ngettext (const char *__msgid1, const char *__msgid2, + unsigned long int __n) + noexcept (true) __attribute__ ((__format_arg__ (1))) __attribute__ ((= __format_arg__ (2))); + + + +extern char *dngettext (const char *__domainname, const char *__msgid1, + const char *__msgid2, unsigned long int __n) + noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((= __format_arg__ (3))); + + + +extern char *dcngettext (const char *__domainname, const char *__msgid1, + const char *__msgid2, unsigned long int __n, + int __category) + noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((= __format_arg__ (3))); + + + + + +extern char *textdomain (const char *__domainname) noexcept (true); + + + +extern char *bindtextdomain (const char *__domainname, + const char *__dirname) noexcept (true); + + + +extern char *bind_textdomain_codeset (const char *__domainname, + const char *__codeset) noexcept (true); +# 121 "/usr/include/libintl.h" 3 4 +} +# 37 "/usr/include/riscv64-linux-gnu/c++/13/bits/messages_members.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + messages<_CharT>::messages(size_t __refs) + : facet(__refs), _M_c_locale_messages(_S_get_c_locale()), + _M_name_messages(_S_get_c_name()) + { } + + template + messages<_CharT>::messages(__c_locale __cloc, const char* __s, + size_t __refs) + : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0) + { + if (__builtin_strcmp(__s, _S_get_c_name()) !=3D 0) + { + const size_t __len =3D __builtin_strlen(__s) + 1; + char* __tmp =3D new char[__len]; + __builtin_memcpy(__tmp, __s, __len); + _M_name_messages =3D __tmp; + } + else + _M_name_messages =3D _S_get_c_name(); + + + _M_c_locale_messages =3D _S_clone_c_locale(__cloc); + } + + template + typename messages<_CharT>::catalog + messages<_CharT>::open(const basic_string& __s, const locale& __= loc, + const char* __dir) const + { + bindtextdomain(__s.c_str(), __dir); + return this->do_open(__s, __loc); + } + + + template + messages<_CharT>::~messages() + { + if (_M_name_messages !=3D _S_get_c_name()) + delete [] _M_name_messages; + _S_destroy_c_locale(_M_c_locale_messages); + } + + template + typename messages<_CharT>::catalog + messages<_CharT>::do_open(const basic_string& __s, + const locale&) const + { + + + textdomain(__s.c_str()); + return 0; + } + + template + void + messages<_CharT>::do_close(catalog) const + { } + + + template + messages_byname<_CharT>::messages_byname(const char* __s, size_t __ref= s) + : messages<_CharT>(__refs) + { + if (this->_M_name_messages !=3D locale::facet::_S_get_c_name()) + { + delete [] this->_M_name_messages; + if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) !=3D 0) + { + const size_t __len =3D __builtin_strlen(__s) + 1; + char* __tmp =3D new char[__len]; + __builtin_memcpy(__tmp, __s, __len); + this->_M_name_messages =3D __tmp; + } + else + this->_M_name_messages =3D locale::facet::_S_get_c_name(); + } + + if (__builtin_strcmp(__s, "C") !=3D 0 + && __builtin_strcmp(__s, "POSIX") !=3D 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_messages); + this->_S_create_c_locale(this->_M_c_locale_messages, __s); + } + } + + + template<> + typename messages::catalog + messages::do_open(const basic_string&, + const locale&) const; + + template<> + void + messages::do_close(catalog) const; + + + template<> + typename messages::catalog + messages::do_open(const basic_string&, + const locale&) const; + + template<> + void + messages::do_close(catalog) const; + + + +} +# 2065 "/usr/include/c++/13/bits/locale_facets_nonio.h" 2 3 + + +# 1 "/usr/include/c++/13/bits/codecvt.h" 1 3 +# 39 "/usr/include/c++/13/bits/codecvt.h" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/bits/codecvt.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + class codecvt_base + { + public: + enum result + { + ok, + partial, + error, + noconv + }; + }; +# 70 "/usr/include/c++/13/bits/codecvt.h" 3 + template + class __codecvt_abstract_base + : public locale::facet, public codecvt_base + { + public: + + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; +# 118 "/usr/include/c++/13/bits/codecvt.h" 3 + result + out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { + return this->do_out(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } +# 157 "/usr/include/c++/13/bits/codecvt.h" 3 + result + unshift(state_type& __state, extern_type* __to, extern_type* __to_en= d, + extern_type*& __to_next) const + { return this->do_unshift(__state, __to,__to_end,__to_next); } +# 198 "/usr/include/c++/13/bits/codecvt.h" 3 + result + in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const + { + return this->do_in(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } + + int + encoding() const throw() + { return this->do_encoding(); } + + bool + always_noconv() const throw() + { return this->do_always_noconv(); } + + int + length(state_type& __state, const extern_type* __from, + const extern_type* __end, size_t __max) const + { return this->do_length(__state, __from, __end, __max); } + + int + max_length() const throw() + { return this->do_max_length(); } + + protected: + explicit + __codecvt_abstract_base(size_t __refs =3D 0) : locale::facet(__refs)= { } + + virtual + ~__codecvt_abstract_base() { } +# 239 "/usr/include/c++/13/bits/codecvt.h" 3 + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const =3D 0; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const =3D 0; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const =3D 0; + + virtual int + do_encoding() const throw() =3D 0; + + virtual bool + do_always_noconv() const throw() =3D 0; + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const =3D 0; + + virtual int + do_max_length() const throw() =3D 0; + }; +# 276 "/usr/include/c++/13/bits/codecvt.h" 3 + template + class codecvt + : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> + { + public: + + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs =3D 0) + : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs), + _M_c_locale_codecvt(0) + { } + + explicit + codecvt(__c_locale __cloc, size_t __refs =3D 0); + + protected: + virtual + ~codecvt() { } + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + template + locale::id codecvt<_InternT, _ExternT, _StateT>::id; + + + template<> + class codecvt + : public __codecvt_abstract_base + { + friend class messages; + + public: + + typedef char intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs =3D 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs =3D 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + friend class messages; + + public: + + typedef wchar_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs =3D 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs =3D 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + + typedef char16_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs =3D 0) + : __codecvt_abstract_base(__refs) { } + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + + typedef char32_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs =3D 0) + : __codecvt_abstract_base(__refs) { } + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; +# 698 "/usr/include/c++/13/bits/codecvt.h" 3 + template + class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> + { + public: + explicit + codecvt_byname(const char* __s, size_t __refs =3D 0) + : codecvt<_InternT, _ExternT, _StateT>(__refs) + { + if (__builtin_strcmp(__s, "C") !=3D 0 + && __builtin_strcmp(__s, "POSIX") !=3D 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_codecvt); + this->_S_create_c_locale(this->_M_c_locale_codecvt, __s); + } + } + + + explicit + codecvt_byname(const string& __s, size_t __refs =3D 0) + : codecvt_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~codecvt_byname() { } + }; + + + template<> + class codecvt_byname + : public codecvt + { + public: + explicit + codecvt_byname(const char*, size_t __refs =3D 0) + : codecvt(__refs) { } + + explicit + codecvt_byname(const string& __s, size_t __refs =3D 0) + : codecvt_byname(__s.c_str(), __refs) { } + + protected: + virtual + ~codecvt_byname() { } + }; + + template<> + class codecvt_byname + : public codecvt + { + public: + explicit + codecvt_byname(const char*, size_t __refs =3D 0) + : codecvt(__refs) { } + + explicit + codecvt_byname(const string& __s, size_t __refs =3D 0) + : codecvt_byname(__s.c_str(), __refs) { } + + protected: + virtual + ~codecvt_byname() { } + }; +# 805 "/usr/include/c++/13/bits/codecvt.h" 3 + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + extern template class codecvt_byname; + extern template class codecvt_byname; +# 840 "/usr/include/c++/13/bits/codecvt.h" 3 + +} +# 2068 "/usr/include/c++/13/bits/locale_facets_nonio.h" 2 3 + +# 1 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 1 3 +# 33 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + struct __use_cache<__moneypunct_cache<_CharT, _Intl> > + { + const __moneypunct_cache<_CharT, _Intl>* + operator() (const locale& __loc) const + { + const size_t __i =3D moneypunct<_CharT, _Intl>::id._M_id(); + const locale::facet** __caches =3D __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __moneypunct_cache<_CharT, _Intl>* __tmp =3D 0; + if (true) + { + __tmp =3D new __moneypunct_cache<_CharT, _Intl>; + __tmp->_M_cache(__loc); + } + if (false) + { + delete __tmp; + ; + } + __loc._M_impl->_M_install_cache(__tmp, __i); + } + return static_cast< + const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]); + } + }; + + template + void + __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc) + { + const moneypunct<_CharT, _Intl>& __mp =3D + use_facet >(__loc); + + struct _Scoped_str + { + size_t _M_len; + _CharT* _M_str; + + explicit + _Scoped_str(const basic_string<_CharT>& __str) + : _M_len(__str.size()), _M_str(new _CharT[_M_len]) + { __str.copy(_M_str, _M_len); } + + ~_Scoped_str() { delete[] _M_str; } + + void + _M_release(const _CharT*& __p, size_t& __n) + { + __p =3D _M_str; + __n =3D _M_len; + _M_str =3D 0; + } + }; + + _Scoped_str __curr_symbol(__mp.curr_symbol()); + _Scoped_str __positive_sign(__mp.positive_sign()); + _Scoped_str __negative_sign(__mp.negative_sign()); + + const string& __g =3D __mp.grouping(); + const size_t __g_size =3D __g.size(); + char* const __grouping =3D new char[__g_size]; + __g.copy(__grouping, __g_size); + + + + _M_grouping =3D __grouping; + _M_grouping_size =3D __g_size; + _M_use_grouping =3D (__g_size + && static_cast(__grouping[0]) > 0 + && (__grouping[0] + !=3D __gnu_cxx::__numeric_traits::__max)); + + _M_decimal_point =3D __mp.decimal_point(); + _M_thousands_sep =3D __mp.thousands_sep(); + + __curr_symbol._M_release(_M_curr_symbol, _M_curr_symbol_size); + __positive_sign._M_release(_M_positive_sign, _M_positive_sign_size); + __negative_sign._M_release(_M_negative_sign, _M_negative_sign_size); + + _M_frac_digits =3D __mp.frac_digits(); + _M_pos_format =3D __mp.pos_format(); + _M_neg_format =3D __mp.neg_format(); + + const ctype<_CharT>& __ct =3D use_facet >(__loc); + __ct.widen(money_base::_S_atoms, + money_base::_S_atoms + money_base::_S_end, _M_atoms); + + _M_allocated =3D true; + } + +namespace __cxx11 { + + template + template + _InIter + money_get<_CharT, _InIter>:: + _M_extract(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, string& __units) const + { + typedef char_traits<_CharT> __traits_type; + typedef typename string_type::size_type size_type; + typedef money_base::part part; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + __use_cache<__cache_type> __uc; + const __cache_type* __lc =3D __uc(__loc); + const char_type* __lit =3D __lc->_M_atoms; + + + bool __negative =3D false; + + size_type __sign_size =3D 0; + + const bool __mandatory_sign =3D (__lc->_M_positive_sign_size + && __lc->_M_negative_sign_size); + + string __grouping_tmp; + if (__lc->_M_use_grouping) + __grouping_tmp.reserve(32); + + int __last_pos =3D 0; + + int __n =3D 0; + + bool __testvalid =3D true; + + bool __testdecfound =3D false; + + + string __res; + __res.reserve(32); + + const char_type* __lit_zero =3D __lit + money_base::_S_zero; + const money_base::pattern __p =3D __lc->_M_neg_format; + for (int __i =3D 0; __i < 4 && __testvalid; ++__i) + { + const part __which =3D static_cast(__p.field[__i]); + switch (__which) + { + case money_base::symbol: + + + + + if (__io.flags() & ios_base::showbase || __sign_size > 1 + || __i =3D=3D 0 + || (__i =3D=3D 1 && (__mandatory_sign + || (static_cast(__p.field[0]) + =3D=3D money_base::sign) + || (static_cast(__p.field[2]) + =3D=3D money_base::space))) + || (__i =3D=3D 2 && ((static_cast(__p.field[3]) + =3D=3D money_base::value) + || (__mandatory_sign + && (static_cast(__p.field[3]) + =3D=3D money_base::sign))))) + { + const size_type __len =3D __lc->_M_curr_symbol_size; + size_type __j =3D 0; + for (; __beg !=3D __end && __j < __len + && *__beg =3D=3D __lc->_M_curr_symbol[__j]; + ++__beg, (void)++__j); + if (__j !=3D __len + && (__j || __io.flags() & ios_base::showbase)) + __testvalid =3D false; + } + break; + case money_base::sign: + + if (__lc->_M_positive_sign_size && __beg !=3D __end + && *__beg =3D=3D __lc->_M_positive_sign[0]) + { + __sign_size =3D __lc->_M_positive_sign_size; + ++__beg; + } + else if (__lc->_M_negative_sign_size && __beg !=3D __end + && *__beg =3D=3D __lc->_M_negative_sign[0]) + { + __negative =3D true; + __sign_size =3D __lc->_M_negative_sign_size; + ++__beg; + } + else if (__lc->_M_positive_sign_size + && !__lc->_M_negative_sign_size) + + + __negative =3D true; + else if (__mandatory_sign) + __testvalid =3D false; + break; + case money_base::value: + + + for (; __beg !=3D __end; ++__beg) + { + const char_type __c =3D *__beg; + const char_type* __q =3D __traits_type::find(__lit_zero, + 10, __c); + if (__q !=3D 0) + { + __res +=3D money_base::_S_atoms[__q - __lit]; + ++__n; + } + else if (__c =3D=3D __lc->_M_decimal_point + && !__testdecfound) + { + if (__lc->_M_frac_digits <=3D 0) + break; + + __last_pos =3D __n; + __n =3D 0; + __testdecfound =3D true; + } + else if (__lc->_M_use_grouping + && __c =3D=3D __lc->_M_thousands_sep + && !__testdecfound) + { + if (__n) + { + + __grouping_tmp +=3D static_cast(__n); + __n =3D 0; + } + else + { + __testvalid =3D false; + break; + } + } + else + break; + } + if (__res.empty()) + __testvalid =3D false; + break; + case money_base::space: + + if (__beg !=3D __end && __ctype.is(ctype_base::space, *__beg)) + ++__beg; + else + __testvalid =3D false; + + case money_base::none: + + if (__i !=3D 3) + for (; __beg !=3D __end + && __ctype.is(ctype_base::space, *__beg); ++__beg); + break; + } + } + + + if (__sign_size > 1 && __testvalid) + { + const char_type* __sign =3D __negative ? __lc->_M_negative_sign + : __lc->_M_positive_sign; + size_type __i =3D 1; + for (; __beg !=3D __end && __i < __sign_size + && *__beg =3D=3D __sign[__i]; ++__beg, (void)++__i); + + if (__i !=3D __sign_size) + __testvalid =3D false; + } + + if (__testvalid) + { + + if (__res.size() > 1) + { + const size_type __first =3D __res.find_first_not_of('0'); + const bool __only_zeros =3D __first =3D=3D string::npos; + if (__first) + __res.erase(0, __only_zeros ? __res.size() - 1 : __first); + } + + + if (__negative && __res[0] !=3D '0') + __res.insert(__res.begin(), '-'); + + + if (__grouping_tmp.size()) + { + + __grouping_tmp +=3D static_cast(__testdecfound ? __last_pos + : __n); + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __grouping_tmp)) + __err |=3D ios_base::failbit; + } + + + if (__testdecfound && __n !=3D __lc->_M_frac_digits) + __testvalid =3D false; + } + + + if (!__testvalid) + __err |=3D ios_base::failbit; + else + __units.swap(__res); + + + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } +# 368 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 + template + _InIter + money_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const + { + string __str; + __beg =3D __intl ? _M_extract(__beg, __end, __io, __err, __str) + : _M_extract(__beg, __end, __io, __err, __str); + std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale()= ); + return __beg; + } + + template + _InIter + money_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const + { + typedef typename string::size_type size_type; + + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + string __str; + __beg =3D __intl ? _M_extract(__beg, __end, __io, __err, __str) + : _M_extract(__beg, __end, __io, __err, __str); + const size_type __len =3D __str.size(); + if (__len) + { + __digits.resize(__len); + __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]); + } + return __beg; + } +# 420 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 + template + template + _OutIter + money_put<_CharT, _OutIter>:: + _M_insert(iter_type __s, ios_base& __io, char_type __fill, + const string_type& __digits) const + { + typedef typename string_type::size_type size_type; + typedef money_base::part part; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + __use_cache<__cache_type> __uc; + const __cache_type* __lc =3D __uc(__loc); + const char_type* __lit =3D __lc->_M_atoms; + + + + const char_type* __beg =3D __digits.data(); + + money_base::pattern __p; + const char_type* __sign; + size_type __sign_size; + if (!(*__beg =3D=3D __lit[money_base::_S_minus])) + { + __p =3D __lc->_M_pos_format; + __sign =3D __lc->_M_positive_sign; + __sign_size =3D __lc->_M_positive_sign_size; + } + else + { + __p =3D __lc->_M_neg_format; + __sign =3D __lc->_M_negative_sign; + __sign_size =3D __lc->_M_negative_sign_size; + if (__digits.size()) + ++__beg; + } + + + size_type __len =3D __ctype.scan_not(ctype_base::digit, __beg, + __beg + __digits.size()) - __beg; + if (__len) + { + + + + string_type __value; + __value.reserve(2 * __len); + + + + long __paddec =3D __len - __lc->_M_frac_digits; + if (__paddec > 0) + { + if (__lc->_M_frac_digits < 0) + __paddec =3D __len; + if (__lc->_M_grouping_size) + { + __value.assign(2 * __paddec, char_type()); + _CharT* __vend =3D + std::__add_grouping(&__value[0], __lc->_M_thousands_sep, + __lc->_M_grouping, + __lc->_M_grouping_size, + __beg, __beg + __paddec); + __value.erase(__vend - &__value[0]); + } + else + __value.assign(__beg, __paddec); + } + + + if (__lc->_M_frac_digits > 0) + { + __value +=3D __lc->_M_decimal_point; + if (__paddec >=3D 0) + __value.append(__beg + __paddec, __lc->_M_frac_digits); + else + { + + __value.append(-__paddec, __lit[money_base::_S_zero]); + __value.append(__beg, __len); + } + } + + + const ios_base::fmtflags __f =3D __io.flags() + & ios_base::adjustfield; + __len =3D __value.size() + __sign_size; + __len +=3D ((__io.flags() & ios_base::showbase) + ? __lc->_M_curr_symbol_size : 0); + + string_type __res; + __res.reserve(2 * __len); + + const size_type __width =3D static_cast(__io.width()); + const bool __testipad =3D (__f =3D=3D ios_base::internal + && __len < __width); + + for (int __i =3D 0; __i < 4; ++__i) + { + const part __which =3D static_cast(__p.field[__i]); + switch (__which) + { + case money_base::symbol: + if (__io.flags() & ios_base::showbase) + __res.append(__lc->_M_curr_symbol, + __lc->_M_curr_symbol_size); + break; + case money_base::sign: + + + + if (__sign_size) + __res +=3D __sign[0]; + break; + case money_base::value: + __res +=3D __value; + break; + case money_base::space: + + + + if (__testipad) + __res.append(__width - __len, __fill); + else + __res +=3D __fill; + break; + case money_base::none: + if (__testipad) + __res.append(__width - __len, __fill); + break; + } + } + + + if (__sign_size > 1) + __res.append(__sign + 1, __sign_size - 1); + + + __len =3D __res.size(); + if (__width > __len) + { + if (__f =3D=3D ios_base::left) + + __res.append(__width - __len, __fill); + else + + __res.insert(0, __width - __len, __fill); + __len =3D __width; + } + + + __s =3D std::__write(__s, __res.data(), __len); + } + __io.width(0); + return __s; + } +# 590 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 + template + _OutIter + money_put<_CharT, _OutIter>:: + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + long double __units) const + { + const locale __loc =3D __io.getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + + int __cs_size =3D 64; + char* __cs =3D static_cast(__builtin_alloca(__cs_size)); + + + int __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_si= ze, + "%.*Lf", 0, __units); + + if (__len >=3D __cs_size) + { + __cs_size =3D __len + 1; + __cs =3D static_cast(__builtin_alloca(__cs_size)); + __len =3D std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + "%.*Lf", 0, __units); + } +# 622 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 + string_type __digits(__len, char_type()); + __ctype.widen(__cs, __cs + __len, &__digits[0]); + return __intl ? _M_insert(__s, __io, __fill, __digits) + : _M_insert(__s, __io, __fill, __digits); + } + + template + _OutIter + money_put<_CharT, _OutIter>:: + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + const string_type& __digits) const + { return __intl ? _M_insert(__s, __io, __fill, __digits) + : _M_insert(__s, __io, __fill, __digits); } +# 674 "/usr/include/c++/13/bits/locale_facets_nonio.tcc" 3 +} + + + + + template + time_base::dateorder + time_get<_CharT, _InIter>::do_date_order() const + { return time_base::no_order; } + + + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format, + __time_get_state &__state) const + { + const locale& __loc =3D __io._M_getloc(); + const __timepunct<_CharT>& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + const size_t __len =3D char_traits<_CharT>::length(__format); + + ios_base::iostate __tmperr =3D ios_base::goodbit; + size_t __i =3D 0; + for (; __beg !=3D __end && __i < __len && !__tmperr; ++__i) + { + if (__ctype.narrow(__format[__i], 0) =3D=3D '%') + { + + char __c =3D __ctype.narrow(__format[++__i], 0); + int __mem =3D 0; + if (__c =3D=3D 'E' || __c =3D=3D 'O') + __c =3D __ctype.narrow(__format[++__i], 0); + switch (__c) + { + const char* __cs; + _CharT __wcs[10]; + case 'a': + case 'A': + + const char_type* __days[14]; + __tp._M_days(&__days[0]); + __tp._M_days_abbreviated(&__days[7]); + __beg =3D _M_extract_name(__beg, __end, __mem, __days, + 14, __io, __tmperr); + if (!__tmperr) + { + __tm->tm_wday =3D __mem % 7; + __state._M_have_wday =3D 1; + } + break; + case 'h': + case 'b': + case 'B': + + const char_type* __months[24]; + __tp._M_months(&__months[0]); + __tp._M_months_abbreviated(&__months[12]); + __beg =3D _M_extract_name(__beg, __end, __mem, + __months, 24, __io, __tmperr); + if (!__tmperr) + { + __tm->tm_mon =3D __mem % 12; + __state._M_have_mon =3D 1; + __state._M_want_xday =3D 1; + } + break; + case 'c': + + const char_type* __dt[2]; + __tp._M_date_time_formats(__dt); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __dt[0], __state); + if (!__tmperr) + __state._M_want_xday =3D 1; + break; + case 'C': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 99, 2, + __io, __tmperr); + if (!__tmperr) + { + __state._M_century =3D __mem; + __state._M_have_century =3D 1; + __state._M_want_xday =3D 1; + } + break; + case 'd': + case 'e': + + if (__ctype.is(ctype_base::space, *__beg)) + ++__beg; + __beg =3D _M_extract_num(__beg, __end, __mem, 1, 31, 2, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_mday =3D __mem; + __state._M_have_mday =3D 1; + __state._M_want_xday =3D 1; + } + break; + case 'D': + + __cs =3D "%m/%d/%y"; + __ctype.widen(__cs, __cs + 9, __wcs); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs, __state); + if (!__tmperr) + __state._M_want_xday =3D 1; + break; + case 'H': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 23, 2, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_hour =3D __mem; + __state._M_have_I =3D 0; + } + break; + case 'I': + + __beg =3D _M_extract_num(__beg, __end, __mem, 1, 12, 2, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_hour =3D __mem % 12; + __state._M_have_I =3D 1; + } + break; + case 'j': + + __beg =3D _M_extract_num(__beg, __end, __mem, 1, 366, 3, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_yday =3D __mem - 1; + __state._M_have_yday =3D 1; + } + break; + case 'm': + + __beg =3D _M_extract_num(__beg, __end, __mem, 1, 12, 2, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_mon =3D __mem - 1; + __state._M_have_mon =3D 1; + } + break; + case 'M': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 59, 2, + __io, __tmperr); + if (!__tmperr) + __tm->tm_min =3D __mem; + break; + case 'n': + case 't': + while (__beg !=3D __end + && __ctype.is(ctype_base::space, *__beg)) + ++__beg; + break; + case 'p': + + const char_type* __ampm[2]; + __tp._M_am_pm(&__ampm[0]); + if (!__ampm[0][0] || !__ampm[1][0]) + break; + __beg =3D _M_extract_name(__beg, __end, __mem, __ampm, + 2, __io, __tmperr); + if (!__tmperr && __mem) + __state._M_is_pm =3D 1; + break; + case 'r': + + const char_type* __ampm_format; + __tp._M_am_pm_format(&__ampm_format); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __ampm_format, __state); + break; + case 'R': + + __cs =3D "%H:%M"; + __ctype.widen(__cs, __cs + 6, __wcs); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs, __state); + break; + case 'S': + + + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 60, 2, + + + + __io, __tmperr); + if (!__tmperr) + __tm->tm_sec =3D __mem; + break; + case 'T': + + __cs =3D "%H:%M:%S"; + __ctype.widen(__cs, __cs + 9, __wcs); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs, __state); + break; + case 'U': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 53, 2, + __io, __tmperr); + if (!__tmperr) + { + __state._M_week_no =3D __mem; + __state._M_have_uweek =3D 1; + } + break; + case 'w': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 6, 1, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_wday =3D __mem; + __state._M_have_wday =3D 1; + } + break; + case 'W': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 53, 2, + __io, __tmperr); + if (!__tmperr) + { + __state._M_week_no =3D __mem; + __state._M_have_wweek =3D 1; + } + break; + case 'x': + + const char_type* __dates[2]; + __tp._M_date_formats(__dates); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __dates[0], __state); + break; + case 'X': + + const char_type* __times[2]; + __tp._M_time_formats(__times); + __beg =3D _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __times[0], __state); + break; + case 'y': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 99, 2, + __io, __tmperr); + if (!__tmperr) + { + __state._M_want_century =3D 1; + __state._M_want_xday =3D 1; + + + __c =3D 0; + if (__beg !=3D __end) + __c =3D __ctype.narrow(*__beg, '*'); + if (__c >=3D '0' && __c <=3D '9') + { + ++__beg; + __mem =3D __mem * 10 + (__c - '0'); + if (__beg !=3D __end) + { + __c =3D __ctype.narrow(*__beg, '*'); + if (__c >=3D '0' && __c <=3D '9') + { + ++__beg; + __mem =3D __mem * 10 + (__c - '0'); + } + } + __mem -=3D 1900; + __state._M_want_century =3D 0; + } + + + else if (__mem < 69) + __mem +=3D 100; + __tm->tm_year =3D __mem; + } + break; + case 'Y': + + __beg =3D _M_extract_num(__beg, __end, __mem, 0, 9999, 4, + __io, __tmperr); + if (!__tmperr) + { + __tm->tm_year =3D __mem - 1900; + __state._M_want_century =3D 0; + __state._M_want_xday =3D 1; + } + break; + case 'Z': + + if (__ctype.is(ctype_base::upper, *__beg)) + { + int __tmp; + __beg =3D _M_extract_name(__beg, __end, __tmp, + __timepunct_cache<_CharT>::_S_timezones, + 14, __io, __tmperr); + + + if (__beg !=3D __end && !__tmperr && __tmp =3D=3D 0 + && (*__beg =3D=3D __ctype.widen('-') + || *__beg =3D=3D __ctype.widen('+'))) + { + __beg =3D _M_extract_num(__beg, __end, __tmp, 0, 23, 2, + __io, __tmperr); + __beg =3D _M_extract_num(__beg, __end, __tmp, 0, 59, 2, + __io, __tmperr); + } + } + else + __tmperr |=3D ios_base::failbit; + break; + case '%': + if (*__beg =3D=3D __ctype.widen('%')) + ++__beg; + else + __tmperr |=3D ios_base::failbit; + break; + default: + + __tmperr |=3D ios_base::failbit; + } + } + else if (__ctype.is(ctype_base::space, __format[__i])) + { + + while (__beg !=3D __end + && __ctype.is(ctype_base::space, *__beg)) + ++__beg; + } + else + { + + + if (__ctype.tolower(__format[__i]) =3D=3D __ctype.tolower(*__beg) + || __ctype.toupper(__format[__i]) =3D=3D __ctype.toupper(*__beg)) + ++__beg; + else + __tmperr |=3D ios_base::failbit; + } + } + + if (__tmperr || __i !=3D __len) + __err |=3D ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format) const + { + __time_get_state __state =3D __time_get_state(); + return _M_extract_via_format(__beg, __end, __io, __err, __tm, + __format, __state); + } + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_num(iter_type __beg, iter_type __end, int& __member, + int __min, int __max, size_t __len, + ios_base& __io, ios_base::iostate& __err) const + { + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + size_t __i =3D 0; + int __value =3D 0; + for (; __beg !=3D __end && __i < __len; ++__beg, (void)++__i) + { + const char __c =3D __ctype.narrow(*__beg, '*'); + if (__c >=3D '0' && __c <=3D '9') + { + __value =3D __value * 10 + (__c - '0'); + if (__value > __max) + break; + } + else + break; + } + if (__i && __value >=3D __min && __value <=3D __max) + __member =3D __value; + else + __err |=3D ios_base::failbit; + + return __beg; + } + + + + + + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_name(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + size_t* __matches + =3D static_cast(__builtin_alloca(2 * sizeof(size_t) + * __indexlen)); + size_t* __lengths =3D __matches + __indexlen; + size_t __nmatches =3D 0; + size_t __pos =3D 0; + bool __testvalid =3D true; + const char_type* __name; + bool __begupdated =3D false; + + + if (__beg !=3D __end) + { + const char_type __c =3D *__beg; + + const char_type __cl =3D __ctype.tolower(__c); + const char_type __cu =3D __ctype.toupper(__c); + for (size_t __i1 =3D 0; __i1 < __indexlen; ++__i1) + if (__cl =3D=3D __ctype.tolower(__names[__i1][0]) + || __cu =3D=3D __ctype.toupper(__names[__i1][0])) + { + __lengths[__nmatches] + =3D __traits_type::length(__names[__i1]); + __matches[__nmatches++] =3D __i1; + } + } + + while (__nmatches > 1) + { + + size_t __minlen =3D __lengths[0]; + for (size_t __i2 =3D 1; __i2 < __nmatches; ++__i2) + __minlen =3D std::min(__minlen, __lengths[__i2]); + ++__pos; + ++__beg; + if (__pos =3D=3D __minlen) + { + + + + + + + bool __match_longer =3D false; + + if (__beg !=3D __end) + { + + const char_type __cl =3D __ctype.tolower(*__beg); + const char_type __cu =3D __ctype.toupper(*__beg); + for (size_t __i3 =3D 0; __i3 < __nmatches; ++__i3) + { + __name =3D __names[__matches[__i3]]; + if (__lengths[__i3] > __pos + && (__ctype.tolower(__name[__pos]) =3D=3D __cl + || __ctype.toupper(__name[__pos]) =3D=3D __cu)) + { + __match_longer =3D true; + break; + } + } + } + for (size_t __i4 =3D 0; __i4 < __nmatches;) + if (__match_longer =3D=3D (__lengths[__i4] =3D=3D __pos)) + { + __matches[__i4] =3D __matches[--__nmatches]; + __lengths[__i4] =3D __lengths[__nmatches]; + } + else + ++__i4; + if (__match_longer) + { + __minlen =3D __lengths[0]; + for (size_t __i5 =3D 1; __i5 < __nmatches; ++__i5) + __minlen =3D std::min(__minlen, __lengths[__i5]); + } + else + { + + + if (__nmatches =3D=3D 2 && (__indexlen & 1) =3D=3D 0) + { + if (__matches[0] < __indexlen / 2) + { + if (__matches[1] =3D=3D __matches[0] + __indexlen / 2) + __nmatches =3D 1; + } + else if (__matches[1] =3D=3D __matches[0] - __indexlen / 2) + { + __matches[0] =3D __matches[1]; + __lengths[0] =3D __lengths[1]; + __nmatches =3D 1; + } + } + __begupdated =3D true; + break; + } + } + if (__pos < __minlen && __beg !=3D __end) + { + + const char_type __cl =3D __ctype.tolower(*__beg); + const char_type __cu =3D __ctype.toupper(*__beg); + for (size_t __i6 =3D 0; __i6 < __nmatches;) + { + __name =3D __names[__matches[__i6]]; + if (__ctype.tolower(__name[__pos]) !=3D __cl + && __ctype.toupper(__name[__pos]) !=3D __cu) + { + __matches[__i6] =3D __matches[--__nmatches]; + __lengths[__i6] =3D __lengths[__nmatches]; + } + else + ++__i6; + } + } + else + break; + } + + if (__nmatches =3D=3D 1) + { + + if (!__begupdated) + { + ++__beg; + ++__pos; + } + __name =3D __names[__matches[0]]; + const size_t __len =3D __lengths[0]; + while (__pos < __len + && __beg !=3D __end + + && (__ctype.tolower(__name[__pos]) =3D=3D __ctype.tolower(*__beg) + || (__ctype.toupper(__name[__pos]) + =3D=3D __ctype.toupper(*__beg)))) + ++__beg, (void)++__pos; + + if (__len =3D=3D __pos) + __member =3D __matches[0]; + else + __testvalid =3D false; + } + else + __testvalid =3D false; + if (!__testvalid) + __err |=3D ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __memb= er, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + int* __matches =3D static_cast(__builtin_alloca(2 * sizeof(int) + * __indexlen)); + size_t __nmatches =3D 0; + size_t* __matches_lengths =3D 0; + size_t __pos =3D 0; + + if (__beg !=3D __end) + { + const char_type __c =3D *__beg; + for (size_t __i =3D 0; __i < 2 * __indexlen; ++__i) + if (__c =3D=3D __names[__i][0] + || __c =3D=3D __ctype.toupper(__names[__i][0])) + __matches[__nmatches++] =3D __i; + } + + if (__nmatches) + { + ++__beg; + ++__pos; + + __matches_lengths + =3D static_cast(__builtin_alloca(sizeof(size_t) + * __nmatches)); + for (size_t __i =3D 0; __i < __nmatches; ++__i) + __matches_lengths[__i] + =3D __traits_type::length(__names[__matches[__i]]); + } + + for (; __beg !=3D __end; ++__beg, (void)++__pos) + { + size_t __nskipped =3D 0; + const char_type __c =3D *__beg; + for (size_t __i =3D 0; __i < __nmatches;) + { + const char_type* __name =3D __names[__matches[__i]]; + if (__pos >=3D __matches_lengths[__i]) + ++__nskipped, ++__i; + else if (!(__name[__pos] =3D=3D __c)) + { + --__nmatches; + __matches[__i] =3D __matches[__nmatches]; + __matches_lengths[__i] =3D __matches_lengths[__nmatches]; + } + else + ++__i; + } + if (__nskipped =3D=3D __nmatches) + break; + } + + if ((__nmatches =3D=3D 1 && __matches_lengths[0] =3D=3D __pos) + || (__nmatches =3D=3D 2 && (__matches_lengths[0] =3D=3D __pos + || __matches_lengths[1] =3D=3D __pos))) + __member =3D (__matches[0] >=3D (int)__indexlen + ? __matches[0] - (int)__indexlen : __matches[0]); + else + __err |=3D ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc =3D __io._M_getloc(); + const __timepunct<_CharT>& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + const char_type* __times[2]; + __tp._M_time_formats(__times); + __time_get_state __state =3D __time_get_state(); + __beg =3D _M_extract_via_format(__beg, __end, __io, __err, + __tm, __times[0], __state); + __state._M_finalize_state(__tm); + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc =3D __io._M_getloc(); + const __timepunct<_CharT>& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + const char_type* __dates[2]; + __tp._M_date_formats(__dates); + __time_get_state __state =3D __time_get_state(); + __beg =3D _M_extract_via_format(__beg, __end, __io, __err, + __tm, __dates[0], __state); + __state._M_finalize_state(__tm); + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc =3D __io._M_getloc(); + const __timepunct<_CharT>& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + const char_type* __days[14]; + __tp._M_days_abbreviated(__days); + __tp._M_days(__days + 7); + int __tmpwday; + ios_base::iostate __tmperr =3D ios_base::goodbit; + + __beg =3D _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, = 7, + __io, __tmperr); + if (!__tmperr) + __tm->tm_wday =3D __tmpwday; + else + __err |=3D ios_base::failbit; + + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_monthname(iter_type __beg, iter_type __end, + ios_base& __io, ios_base::iostate& __err, tm* __tm) c= onst + { + const locale& __loc =3D __io._M_getloc(); + const __timepunct<_CharT>& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + const char_type* __months[24]; + __tp._M_months_abbreviated(__months); + __tp._M_months(__months + 12); + int __tmpmon; + ios_base::iostate __tmperr =3D ios_base::goodbit; + + __beg =3D _M_extract_wday_or_month(__beg, __end, __tmpmon, __months,= 12, + __io, __tmperr); + if (!__tmperr) + __tm->tm_mon =3D __tmpmon; + else + __err |=3D ios_base::failbit; + + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + int __tmpyear; + ios_base::iostate __tmperr =3D ios_base::goodbit; + const locale& __loc =3D __io._M_getloc(); + const ctype<_CharT>& __ctype =3D use_facet >(__loc); + + __beg =3D _M_extract_num(__beg, __end, __tmpyear, 0, 99, 2, + __io, __tmperr); + if (!__tmperr) + { + char __c =3D 0; + if (__beg !=3D __end) + __c =3D __ctype.narrow(*__beg, '*'); + + + + if (__c >=3D '0' && __c <=3D '9') + { + ++__beg; + __tmpyear =3D __tmpyear * 10 + (__c - '0'); + if (__beg !=3D __end) + { + __c =3D __ctype.narrow(*__beg, '*'); + if (__c >=3D '0' && __c <=3D '9') + { + ++__beg; + __tmpyear =3D __tmpyear * 10 + (__c - '0'); + } + } + __tmpyear -=3D 1900; + } + else if (__tmpyear < 69) + __tmpyear +=3D 100; + __tm->tm_year =3D __tmpyear; + } + else + __err |=3D ios_base::failbit; + + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + + template + inline + _InIter + time_get<_CharT, _InIter>:: + get(iter_type __s, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, const char_type* __fmt, + const char_type* __fmtend) const + { + const locale& __loc =3D __io._M_getloc(); + ctype<_CharT> const& __ctype =3D use_facet >(__loc); + __err =3D ios_base::goodbit; + bool __use_state =3D false; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpmf-conversions" + + + + + + + if ((void*)(this->*(&time_get::do_get)) =3D=3D (void*)(&time_get::do= _get)) + __use_state =3D true; +#pragma GCC diagnostic pop + + __time_get_state __state =3D __time_get_state(); + while (__fmt !=3D __fmtend && + __err =3D=3D ios_base::goodbit) + { + if (__s =3D=3D __end) + { + __err =3D ios_base::eofbit | ios_base::failbit; + break; + } + else if (__ctype.narrow(*__fmt, 0) =3D=3D '%') + { + const char_type* __fmt_start =3D __fmt; + char __format; + char __mod =3D 0; + if (++__fmt =3D=3D __fmtend) + { + __err =3D ios_base::failbit; + break; + } + const char __c =3D __ctype.narrow(*__fmt, 0); + if (__c !=3D 'E' && __c !=3D 'O') + __format =3D __c; + else if (++__fmt !=3D __fmtend) + { + __mod =3D __c; + __format =3D __ctype.narrow(*__fmt, 0); + } + else + { + __err =3D ios_base::failbit; + break; + } + if (__use_state) + { + char_type __new_fmt[4]; + __new_fmt[0] =3D __fmt_start[0]; + __new_fmt[1] =3D __fmt_start[1]; + if (__mod) + { + __new_fmt[2] =3D __fmt_start[2]; + __new_fmt[3] =3D char_type(); + } + else + __new_fmt[2] =3D char_type(); + __s =3D _M_extract_via_format(__s, __end, __io, __err, __tm, + __new_fmt, __state); + if (__s =3D=3D __end) + __err |=3D ios_base::eofbit; + } + else + __s =3D this->do_get(__s, __end, __io, __err, __tm, __format, + __mod); + ++__fmt; + } + else if (__ctype.is(ctype_base::space, *__fmt)) + { + ++__fmt; + while (__fmt !=3D __fmtend && + __ctype.is(ctype_base::space, *__fmt)) + ++__fmt; + + while (__s !=3D __end && + __ctype.is(ctype_base::space, *__s)) + ++__s; + } + + else if (__ctype.tolower(*__s) =3D=3D __ctype.tolower(*__fmt) || + __ctype.toupper(*__s) =3D=3D __ctype.toupper(*__fmt)) + { + ++__s; + ++__fmt; + } + else + { + __err =3D ios_base::failbit; + break; + } + } + if (__use_state) + __state._M_finalize_state(__tm); + return __s; + } + + template + inline + _InIter + time_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, + char __format, char __mod) const + { + const locale& __loc =3D __io._M_getloc(); + ctype<_CharT> const& __ctype =3D use_facet >(__loc); + __err =3D ios_base::goodbit; + + char_type __fmt[4]; + __fmt[0] =3D __ctype.widen('%'); + if (!__mod) + { + __fmt[1] =3D __format; + __fmt[2] =3D char_type(); + } + else + { + __fmt[1] =3D __mod; + __fmt[2] =3D __format; + __fmt[3] =3D char_type(); + } + + __time_get_state __state =3D __time_get_state(); + __beg =3D _M_extract_via_format(__beg, __end, __io, __err, __tm, __f= mt, + __state); + __state._M_finalize_state(__tm); + if (__beg =3D=3D __end) + __err |=3D ios_base::eofbit; + return __beg; + } + + + + template + _OutIter + time_put<_CharT, _OutIter>:: + put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, + const _CharT* __beg, const _CharT* __end) const + { + const locale& __loc =3D __io._M_getloc(); + ctype<_CharT> const& __ctype =3D use_facet >(__loc); + for (; __beg !=3D __end; ++__beg) + if (__ctype.narrow(*__beg, 0) !=3D '%') + { + *__s =3D *__beg; + ++__s; + } + else if (++__beg !=3D __end) + { + char __format; + char __mod =3D 0; + const char __c =3D __ctype.narrow(*__beg, 0); + if (__c !=3D 'E' && __c !=3D 'O') + __format =3D __c; + else if (++__beg !=3D __end) + { + __mod =3D __c; + __format =3D __ctype.narrow(*__beg, 0); + } + else + break; + __s =3D this->do_put(__s, __io, __fill, __tm, __format, __mod); + } + else + break; + return __s; + } + + template + _OutIter + time_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm, + char __format, char __mod) const + { + const locale& __loc =3D __io._M_getloc(); + ctype<_CharT> const& __ctype =3D use_facet >(__loc); + __timepunct<_CharT> const& __tp =3D use_facet<__timepunct<_CharT> >(= __loc); + + + + const size_t __maxlen =3D 128; + char_type __res[__maxlen]; + + + + + + + char_type __fmt[4]; + __fmt[0] =3D __ctype.widen('%'); + if (!__mod) + { + __fmt[1] =3D __format; + __fmt[2] =3D char_type(); + } + else + { + __fmt[1] =3D __mod; + __fmt[2] =3D __format; + __fmt[3] =3D char_type(); + } + + __tp._M_put(__res, __maxlen, __fmt, __tm); + + + return std::__write(__s, __res, char_traits::length(__res= )); + } + + + + + + extern template class moneypunct; + extern template class moneypunct; + extern template class moneypunct_byname; + extern template class moneypunct_byname; + extern template class __cxx11:: money_get; + extern template class __cxx11:: money_put; + extern template class __timepunct; + extern template class time_put; + extern template class time_put_byname; + extern template class time_get; + extern template class time_get_byname; + extern template class messages; + extern template class messages_byname; + + extern template + const moneypunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const moneypunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const money_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const money_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const __timepunct* + __try_use_facet<__timepunct >(const locale&) noexcept; + + extern template + const time_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const time_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const messages* + __try_use_facet >(const locale&) noexcept; + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const money_put& + use_facet >(const locale&); + + extern template + const money_get& + use_facet >(const locale&); + + extern template + const __timepunct& + use_facet<__timepunct >(const locale&); + + extern template + const time_put& + use_facet >(const locale&); + + extern template + const time_get& + use_facet >(const locale&); + + extern template + const messages& + 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<__timepunct >(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 moneypunct; + extern template class moneypunct; + extern template class moneypunct_byname; + extern template class moneypunct_byname; + extern template class __cxx11:: money_get; + extern template class __cxx11:: money_put; + extern template class __timepunct; + extern template class time_put; + extern template class time_put_byname; + extern template class time_get; + extern template class time_get_byname; + extern template class messages; + extern template class messages_byname; + + extern template + const moneypunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const moneypunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const money_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const money_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const __timepunct* + __try_use_facet<__timepunct >(const locale&) noexcept; + + extern template + const time_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const time_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const messages* + __try_use_facet >(const locale&) noexcept; + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const money_put& + use_facet >(const locale&); + + extern template + const money_get& + use_facet >(const locale&); + + extern template + const __timepunct& + use_facet<__timepunct >(const locale&); + + extern template + const time_put& + use_facet >(const locale&); + + extern template + const time_get& + use_facet >(const locale&); + + extern template + const messages& + 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<__timepunct >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 2070 "/usr/include/c++/13/bits/locale_facets_nonio.h" 2 3 +# 44 "/usr/include/c++/13/locale" 2 3 + +# 1 "/usr/include/c++/13/bits/locale_conv.h" 1 3 +# 42 "/usr/include/c++/13/bits/locale_conv.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + bool + __do_str_codecvt(const _InChar* __first, const _InChar* __last, + _OutStr& __outstr, const _Codecvt& __cvt, _State& __state, + size_t& __count, _Fn __fn) + { + if (__first =3D=3D __last) + { + __outstr.clear(); + __count =3D 0; + return true; + } + + size_t __outchars =3D 0; + auto __next =3D __first; + const auto __maxlen =3D __cvt.max_length() + 1; + + codecvt_base::result __result; + do + { + __outstr.resize(__outstr.size() + (__last - __next) * __maxlen); + auto __outnext =3D &__outstr.front() + __outchars; + auto const __outlast =3D &__outstr.back() + 1; + __result =3D (__cvt.*__fn)(__state, __next, __last, __next, + __outnext, __outlast, __outnext); + __outchars =3D __outnext - &__outstr.front(); + } + while (__result =3D=3D codecvt_base::partial && __next !=3D __last + && ptrdiff_t(__outstr.size() - __outchars) < __maxlen); + + if (__result =3D=3D codecvt_base::error) + { + __count =3D __next - __first; + return false; + } + + + + if constexpr (is_same()) + if (__result =3D=3D codecvt_base::noconv) + { + __outstr.assign(__first, __last); + __count =3D __last - __first; + return true; + } + + __outstr.resize(__outchars); + __count =3D __next - __first; + return true; + } + + + template + inline bool + __str_codecvt_in(const char* __first, const char* __last, + basic_string<_CharT, _Traits, _Alloc>& __outstr, + const codecvt<_CharT, char, _State>& __cvt, + _State& __state, size_t& __count) + { + using _Codecvt =3D codecvt<_CharT, char, _State>; + using _ConvFn + =3D codecvt_base::result + (_Codecvt::*)(_State&, const char*, const char*, const char*&, + _CharT*, _CharT*, _CharT*&) const; + _ConvFn __fn =3D &codecvt<_CharT, char, _State>::in; + return __do_str_codecvt(__first, __last, __outstr, __cvt, __state, + __count, __fn); + } + + + template + inline bool + __str_codecvt_in(const char* __first, const char* __last, + basic_string<_CharT, _Traits, _Alloc>& __outstr, + const codecvt<_CharT, char, _State>& __cvt) + { + _State __state =3D {}; + size_t __n; + return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, _= _n); + } + + + template + inline bool + __str_codecvt_in_all(const char* __first, const char* __last, + basic_string<_CharT, _Traits, _Alloc>& __outstr, + const codecvt<_CharT, char, _State>& __cvt) + { + _State __state =3D {}; + size_t __n; + return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, _= _n) + && (__n =3D=3D size_t(__last - __first)); + } + + + template + inline bool + __str_codecvt_out(const _CharT* __first, const _CharT* __last, + basic_string& __outstr, + const codecvt<_CharT, char, _State>& __cvt, + _State& __state, size_t& __count) + { + using _Codecvt =3D codecvt<_CharT, char, _State>; + using _ConvFn + =3D codecvt_base::result + (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&, + char*, char*, char*&) const; + _ConvFn __fn =3D &codecvt<_CharT, char, _State>::out; + return __do_str_codecvt(__first, __last, __outstr, __cvt, __state, + __count, __fn); + } + + + template + inline bool + __str_codecvt_out(const _CharT* __first, const _CharT* __last, + basic_string& __outstr, + const codecvt<_CharT, char, _State>& __cvt) + { + _State __state =3D {}; + size_t __n; + return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, = __n); + } + + + template + inline bool + __str_codecvt_out_all(const _CharT* __first, const _CharT* __last, + basic_string& __outstr, + const codecvt<_CharT, char, _State>& __cvt) + { + _State __state =3D {}; + size_t __n; + return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, = __n) + && (__n =3D=3D size_t(__last - __first)); + } +# 223 "/usr/include/c++/13/bits/locale_conv.h" 3 + namespace __detail + { + template + struct _Scoped_ptr + { + __attribute__((__nonnull__(2))) + explicit + _Scoped_ptr(_Tp* __ptr) noexcept + : _M_ptr(__ptr) + { } + + _Scoped_ptr(_Tp* __ptr, const char* __msg) + : _M_ptr(__ptr) + { + if (!__ptr) + __throw_logic_error(__msg); + } + + ~_Scoped_ptr() { delete _M_ptr; } + + _Scoped_ptr(const _Scoped_ptr&) =3D delete; + _Scoped_ptr& operator=3D(const _Scoped_ptr&) =3D delete; + + __attribute__((__returns_nonnull__)) + _Tp* operator->() const noexcept { return _M_ptr; } + + _Tp& operator*() const noexcept { return *_M_ptr; } + + private: + _Tp* _M_ptr; + }; + } + +namespace __cxx11 { + + + template, + typename _Byte_alloc =3D allocator> + class wstring_convert + { + public: + typedef basic_string, _Byte_alloc> byte_stri= ng; + typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_st= ring; + typedef typename _Codecvt::state_type state_type; + typedef typename wide_string::traits_type::int_type int_type; + + + wstring_convert() : _M_cvt(new _Codecvt()) { } + + + + + + + + explicit + wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt, "wstring_convert") + { } +# 291 "/usr/include/c++/13/bits/locale_conv.h" 3 + wstring_convert(_Codecvt* __pcvt, state_type __state) + : _M_cvt(__pcvt, "wstring_convert"), + _M_state(__state), _M_with_cvtstate(true) + { } + + + + + + + explicit + wstring_convert(const byte_string& __byte_err, + const wide_string& __wide_err =3D wide_string()) + : _M_cvt(new _Codecvt), + _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err), + _M_with_strings(true) + { } + + ~wstring_convert() =3D default; + + + + wstring_convert(const wstring_convert&) =3D delete; + wstring_convert& operator=3D(const wstring_convert&) =3D delete; + + + wide_string + from_bytes(char __byte) + { + char __bytes[2] =3D { __byte }; + return from_bytes(__bytes, __bytes+1); + } + + wide_string + from_bytes(const char* __ptr) + { return from_bytes(__ptr, __ptr+char_traits::length(__ptr)); } + + wide_string + from_bytes(const byte_string& __str) + { + auto __ptr =3D __str.data(); + return from_bytes(__ptr, __ptr + __str.size()); + } + + wide_string + from_bytes(const char* __first, const char* __last) + { + if (!_M_with_cvtstate) + _M_state =3D state_type(); + wide_string __out{ _M_wide_err_string.get_allocator() }; + if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state, + _M_count)) + return __out; + if (_M_with_strings) + return _M_wide_err_string; + __throw_range_error("wstring_convert::from_bytes"); + } + + + + byte_string + to_bytes(_Elem __wchar) + { + _Elem __wchars[2] =3D { __wchar }; + return to_bytes(__wchars, __wchars+1); + } + + byte_string + to_bytes(const _Elem* __ptr) + { + return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr)); + } + + byte_string + to_bytes(const wide_string& __wstr) + { + auto __ptr =3D __wstr.data(); + return to_bytes(__ptr, __ptr + __wstr.size()); + } + + byte_string + to_bytes(const _Elem* __first, const _Elem* __last) + { + if (!_M_with_cvtstate) + _M_state =3D state_type(); + byte_string __out{ _M_byte_err_string.get_allocator() }; + if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state, + _M_count)) + return __out; + if (_M_with_strings) + return _M_byte_err_string; + __throw_range_error("wstring_convert::to_bytes"); + } + + + + + + size_t converted() const noexcept { return _M_count; } + + + state_type state() const { return _M_state; } + + private: + __detail::_Scoped_ptr<_Codecvt> _M_cvt; + byte_string _M_byte_err_string; + wide_string _M_wide_err_string; + state_type _M_state =3D state_type(); + size_t _M_count =3D 0; + bool _M_with_cvtstate =3D false; + bool _M_with_strings =3D false; + }; + +} + + + template> + class wbuffer_convert : public basic_streambuf<_Elem, _Tr> + { + typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf; + + public: + typedef typename _Codecvt::state_type state_type; + + + wbuffer_convert() : wbuffer_convert(nullptr) { } +# 427 "/usr/include/c++/13/bits/locale_conv.h" 3 + explicit + wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt =3D new _Code= cvt, + state_type __state =3D state_type()) + : _M_buf(__bytebuf), _M_cvt(__pcvt, "wbuffer_convert"), + _M_state(__state), _M_always_noconv(_M_cvt->always_noconv()) + { + if (_M_buf) + { + this->setp(_M_put_area, _M_put_area + _S_buffer_length); + this->setg(_M_get_area + _S_putback_length, + _M_get_area + _S_putback_length, + _M_get_area + _S_putback_length); + } + } + + ~wbuffer_convert() =3D default; + + + + wbuffer_convert(const wbuffer_convert&) =3D delete; + wbuffer_convert& operator=3D(const wbuffer_convert&) =3D delete; + + streambuf* rdbuf() const noexcept { return _M_buf; } + + streambuf* + rdbuf(streambuf *__bytebuf) noexcept + { + auto __prev =3D _M_buf; + _M_buf =3D __bytebuf; + return __prev; + } + + + state_type state() const noexcept { return _M_state; } + + protected: + int + sync() + { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; } + + typename _Wide_streambuf::int_type + overflow(typename _Wide_streambuf::int_type __out) + { + if (!_M_buf || !_M_conv_put()) + return _Tr::eof(); + else if (!_Tr::eq_int_type(__out, _Tr::eof())) + return this->sputc(__out); + return _Tr::not_eof(__out); + } + + typename _Wide_streambuf::int_type + underflow() + { + if (!_M_buf) + return _Tr::eof(); + + if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get())) + return _Tr::to_int_type(*this->gptr()); + else + return _Tr::eof(); + } + + streamsize + xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __= n) + { + if (!_M_buf || __n =3D=3D 0) + return 0; + streamsize __done =3D 0; + do + { + auto __nn =3D std::min(this->epptr() - this->pptr(), + __n - __done); + _Tr::copy(this->pptr(), __s + __done, __nn); + this->pbump(__nn); + __done +=3D __nn; + } while (__done < __n && _M_conv_put()); + return __done; + } + + private: + + bool + _M_conv_get() + { + const streamsize __pb1 =3D this->gptr() - this->eback(); + const streamsize __pb2 =3D _S_putback_length; + const streamsize __npb =3D std::min(__pb1, __pb2); + + _Tr::move(_M_get_area + _S_putback_length - __npb, + this->gptr() - __npb, __npb); + + streamsize __nbytes =3D sizeof(_M_get_buf) - _M_unconv; + __nbytes =3D std::min(__nbytes, _M_buf->in_avail()); + if (__nbytes < 1) + __nbytes =3D 1; + __nbytes =3D _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes); + if (__nbytes < 1) + return false; + __nbytes +=3D _M_unconv; + + + + _Elem* __outbuf =3D _M_get_area + _S_putback_length; + _Elem* __outnext =3D __outbuf; + const char* __bnext =3D _M_get_buf; + + codecvt_base::result __result; + if (_M_always_noconv) + __result =3D codecvt_base::noconv; + else + { + _Elem* __outend =3D _M_get_area + _S_buffer_length; + + __result =3D _M_cvt->in(_M_state, + __bnext, __bnext + __nbytes, __bnext, + __outbuf, __outend, __outnext); + } + + if (__result =3D=3D codecvt_base::noconv) + { + + auto __get_buf =3D reinterpret_cast(_M_get_buf); + _Tr::copy(__outbuf, __get_buf, __nbytes); + _M_unconv =3D 0; + return true; + } + + if ((_M_unconv =3D _M_get_buf + __nbytes - __bnext)) + char_traits::move(_M_get_buf, __bnext, _M_unconv); + + this->setg(__outbuf, __outbuf, __outnext); + + return __result !=3D codecvt_base::error; + } + + + bool + _M_put(...) + { return false; } + + bool + _M_put(const char* __p, streamsize __n) + { + if (_M_buf->sputn(__p, __n) < __n) + return false; + return true; + } + + + bool + _M_conv_put() + { + _Elem* const __first =3D this->pbase(); + const _Elem* const __last =3D this->pptr(); + const streamsize __pending =3D __last - __first; + + if (_M_always_noconv) + return _M_put(__first, __pending); + + char __outbuf[2 * _S_buffer_length]; + + const _Elem* __next =3D __first; + const _Elem* __start; + do + { + __start =3D __next; + char* __outnext =3D __outbuf; + char* const __outlast =3D __outbuf + sizeof(__outbuf); + auto __result =3D _M_cvt->out(_M_state, __next, __last, __next, + __outnext, __outlast, __outnext); + if (__result =3D=3D codecvt_base::error) + return false; + else if (__result =3D=3D codecvt_base::noconv) + return _M_put(__next, __pending); + + if (!_M_put(__outbuf, __outnext - __outbuf)) + return false; + } + while (__next !=3D __last && __next !=3D __start); + + if (__next !=3D __last) + _Tr::move(__first, __next, __last - __next); + + this->pbump(__first - __next); + return __next !=3D __first; + } + + streambuf* _M_buf; + __detail::_Scoped_ptr<_Codecvt> _M_cvt; + state_type _M_state; + + static const streamsize _S_buffer_length =3D 32; + static const streamsize _S_putback_length =3D 3; + _Elem _M_put_area[_S_buffer_length]; + _Elem _M_get_area[_S_buffer_length]; + streamsize _M_unconv =3D 0; + char _M_get_buf[_S_buffer_length-_S_putback_length]; + bool _M_always_noconv; + }; + + + + +} +# 46 "/usr/include/c++/13/locale" 2 3 +# 270 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 278 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/sys/stat.h" 1 3 4 +# 99 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern "C" { + +# 1 "/usr/include/riscv64-linux-gnu/bits/stat.h" 1 3 4 +# 25 "/usr/include/riscv64-linux-gnu/bits/stat.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 2 3 4 +# 44 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 3 4 +struct stat + { + __dev_t st_dev; + __ino_t st_ino; + __mode_t st_mode; + __nlink_t st_nlink; + __uid_t st_uid; + __gid_t st_gid; + __dev_t st_rdev; + __dev_t __pad1; + __off_t st_size; + __blksize_t st_blksize; + int __pad2; + __blkcnt_t st_blocks; + + + + + + + + struct timespec st_atim; + struct timespec st_mtim; + struct timespec st_ctim; +# 79 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 3 4 + int __glibc_reserved[2]; + }; + + + + +struct stat64 + { + __dev_t st_dev; + __ino64_t st_ino; + __mode_t st_mode; + __nlink_t st_nlink; + __uid_t st_uid; + __gid_t st_gid; + __dev_t st_rdev; + __dev_t __pad1; + __off64_t st_size; + __blksize_t st_blksize; + int __pad2; + __blkcnt64_t st_blocks; + + + + + + + + struct timespec st_atim; + struct timespec st_mtim; + struct timespec st_ctim; +# 117 "/usr/include/riscv64-linux-gnu/bits/struct_stat.h" 3 4 + int __glibc_reserved[2]; + }; +# 26 "/usr/include/riscv64-linux-gnu/bits/stat.h" 2 3 4 +# 102 "/usr/include/riscv64-linux-gnu/sys/stat.h" 2 3 4 +# 205 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int stat (const char *__restrict __file, + struct stat *__restrict __buf) noexcept (true) __attribute__ ((__nonnul= l__ (1, 2))); + + + +extern int fstat (int __fd, struct stat *__buf) noexcept (true) __attribut= e__ ((__nonnull__ (2))); +# 240 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int stat64 (const char *__restrict __file, + struct stat64 *__restrict __buf) noexcept (true) __attribute__ ((__no= nnull__ (1, 2))); +extern int fstat64 (int __fd, struct stat64 *__buf) noexcept (true) __attr= ibute__ ((__nonnull__ (2))); +# 264 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int fstatat (int __fd, const char *__restrict __file, + struct stat *__restrict __buf, int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); +# 291 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int fstatat64 (int __fd, const char *__restrict __file, + struct stat64 *__restrict __buf, int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); +# 313 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int lstat (const char *__restrict __file, + struct stat *__restrict __buf) noexcept (true) __attribute__ ((__nonnu= ll__ (1, 2))); +# 338 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int lstat64 (const char *__restrict __file, + struct stat64 *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 352 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int chmod (const char *__file, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int lchmod (const char *__file, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int fchmod (int __fd, __mode_t __mode) noexcept (true); + + + + + +extern int fchmodat (int __fd, const char *__file, __mode_t __mode, + int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__w= arn_unused_result__)); + + + + + + +extern __mode_t umask (__mode_t __mask) noexcept (true); + + + + +extern __mode_t getumask (void) noexcept (true); + + + +extern int mkdir (const char *__path, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int mkdirat (int __fd, const char *__path, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + + +extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int mknodat (int __fd, const char *__path, __mode_t __mode, + __dev_t __dev) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + +extern int mkfifo (const char *__path, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int mkfifoat (int __fd, const char *__path, __mode_t __mode) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + + +extern int utimensat (int __fd, const char *__path, + const struct timespec __times[2], + int __flags) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 452 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +extern int futimens (int __fd, const struct timespec __times[2]) noexcept = (true); +# 465 "/usr/include/riscv64-linux-gnu/sys/stat.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/statx.h" 1 3 4 +# 31 "/usr/include/riscv64-linux-gnu/bits/statx.h" 3 4 +# 1 "/usr/include/linux/stat.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 +# 27 "/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; +# 50 "/usr/include/linux/types.h" 3 4 +typedef unsigned __poll_t; +# 6 "/usr/include/linux/stat.h" 2 3 4 +# 56 "/usr/include/linux/stat.h" 3 4 +struct statx_timestamp { + __s64 tv_sec; + __u32 tv_nsec; + __s32 __reserved; +}; +# 99 "/usr/include/linux/stat.h" 3 4 +struct statx { + + __u32 stx_mask; + __u32 stx_blksize; + __u64 stx_attributes; + + __u32 stx_nlink; + __u32 stx_uid; + __u32 stx_gid; + __u16 stx_mode; + __u16 __spare0[1]; + + __u64 stx_ino; + __u64 stx_size; + __u64 stx_blocks; + __u64 stx_attributes_mask; + + struct statx_timestamp stx_atime; + struct statx_timestamp stx_btime; + struct statx_timestamp stx_ctime; + struct statx_timestamp stx_mtime; + + __u32 stx_rdev_major; + __u32 stx_rdev_minor; + __u32 stx_dev_major; + __u32 stx_dev_minor; + + __u64 stx_mnt_id; + __u32 stx_dio_mem_align; + __u32 stx_dio_offset_align; + + __u64 __spare3[12]; + +}; +# 32 "/usr/include/riscv64-linux-gnu/bits/statx.h" 2 3 4 + + + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/statx-generic.h" 1 3 4 +# 25 "/usr/include/riscv64-linux-gnu/bits/statx-generic.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_statx_timestamp.h" 1= 3 4 +# 26 "/usr/include/riscv64-linux-gnu/bits/statx-generic.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_statx.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/statx-generic.h" 2 3 4 +# 57 "/usr/include/riscv64-linux-gnu/bits/statx-generic.h" 3 4 +extern "C" { + + +int statx (int __dirfd, const char *__restrict __path, int __flags, + unsigned int __mask, struct statx *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 5))); + +} +# 40 "/usr/include/riscv64-linux-gnu/bits/statx.h" 2 3 4 +# 466 "/usr/include/riscv64-linux-gnu/sys/stat.h" 2 3 4 + + +} +# 279 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 287 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/gtest/internal/custom/gtest-port.h" 1 3 4 +# 288 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 1 "/usr/include/gtest/internal/gtest-port-arch.h" 1 3 4 +# 289 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 373 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/unistd.h" 1 3 4 +# 27 "/usr/include/unistd.h" 3 4 +extern "C" { +# 202 "/usr/include/unistd.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/posix_opt.h" 1 3 4 +# 203 "/usr/include/unistd.h" 2 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/environments.h" 1 3 4 +# 22 "/usr/include/riscv64-linux-gnu/bits/environments.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 +# 23 "/usr/include/riscv64-linux-gnu/bits/environments.h" 2 3 4 +# 207 "/usr/include/unistd.h" 2 3 4 +# 226 "/usr/include/unistd.h" 3 4 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 227 "/usr/include/unistd.h" 2 3 4 +# 274 "/usr/include/unistd.h" 3 4 +typedef __socklen_t socklen_t; +# 287 "/usr/include/unistd.h" 3 4 +extern int access (const char *__name, int __type) noexcept (true) __attri= bute__ ((__nonnull__ (1))); + + + + +extern int euidaccess (const char *__name, int __type) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int eaccess (const char *__name, int __type) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int execveat (int __fd, const char *__path, char *const __argv[], + char *const __envp[], int __flags) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + + +extern int faccessat (int __fd, const char *__file, int __type, int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__w= arn_unused_result__)); +# 339 "/usr/include/unistd.h" 3 4 +extern __off_t lseek (int __fd, __off_t __offset, int __whence) noexcept (= true); +# 350 "/usr/include/unistd.h" 3 4 +extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) + noexcept (true); + + + + + + +extern int close (int __fd); + + + + +extern void closefrom (int __lowfd) noexcept (true); + + + + + + + +extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__= ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + + +extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute= __ ((__warn_unused_result__)) + __attribute__ ((__access__ (__read_only__, 2, 3))); +# 389 "/usr/include/unistd.h" 3 4 +extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, + __off_t __offset) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + + + +extern ssize_t pwrite (int __fd, const void *__buf, size_t __n, + __off_t __offset) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__read_only__, 2, 3))); +# 422 "/usr/include/unistd.h" 3 4 +extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n, + __off64_t __offset) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__read_only__, 2, 3))); + + + + + + + +extern int pipe (int __pipedes[2]) noexcept (true) __attribute__ ((__warn_= unused_result__)); + + + + +extern int pipe2 (int __pipedes[2], int __flags) noexcept (true) __attribu= te__ ((__warn_unused_result__)); +# 452 "/usr/include/unistd.h" 3 4 +extern unsigned int alarm (unsigned int __seconds) noexcept (true); +# 464 "/usr/include/unistd.h" 3 4 +extern unsigned int sleep (unsigned int __seconds); + + + + + + + +extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval) + noexcept (true); + + + + + + +extern int usleep (__useconds_t __useconds); +# 489 "/usr/include/unistd.h" 3 4 +extern int pause (void); + + + +extern int chown (const char *__file, __uid_t __owner, __gid_t __group) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)); + + + +extern int fchown (int __fd, __uid_t __owner, __gid_t __group) noexcept (t= rue) __attribute__ ((__warn_unused_result__)); + + + + +extern int lchown (const char *__file, __uid_t __owner, __gid_t __group) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)); + + + + + + +extern int fchownat (int __fd, const char *__file, __uid_t __owner, + __gid_t __group, int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__w= arn_unused_result__)); + + + +extern int chdir (const char *__path) noexcept (true) __attribute__ ((__no= nnull__ (1))) __attribute__ ((__warn_unused_result__)); + + + +extern int fchdir (int __fd) noexcept (true) __attribute__ ((__warn_unused= _result__)); +# 531 "/usr/include/unistd.h" 3 4 +extern char *getcwd (char *__buf, size_t __size) noexcept (true) __attribu= te__ ((__warn_unused_result__)); + + + + + +extern char *get_current_dir_name (void) noexcept (true); + + + + + + + +extern char *getwd (char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__d= eprecated__)) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 1))); + + + + +extern int dup (int __fd) noexcept (true) __attribute__ ((__warn_unused_re= sult__)); + + +extern int dup2 (int __fd, int __fd2) noexcept (true); + + + + +extern int dup3 (int __fd, int __fd2, int __flags) noexcept (true); + + + +extern char **__environ; + +extern char **environ; + + + + + +extern int execve (const char *__path, char *const __argv[], + char *const __envp[]) noexcept (true) __attribute__ ((__nonnull__ (1,= 2))); + + + + +extern int fexecve (int __fd, char *const __argv[], char *const __envp[]) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + +extern int execv (const char *__path, char *const __argv[]) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int execle (const char *__path, const char *__arg, ...) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int execl (const char *__path, const char *__arg, ...) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int execvp (const char *__file, char *const __argv[]) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int execlp (const char *__file, const char *__arg, ...) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int execvpe (const char *__file, char *const __argv[], + char *const __envp[]) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int nice (int __inc) noexcept (true) __attribute__ ((__warn_unused_= result__)); + + + + +extern void _exit (int __status) __attribute__ ((__noreturn__)); + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/confname.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/confname.h" 3 4 +enum + { + _PC_LINK_MAX, + + _PC_MAX_CANON, + + _PC_MAX_INPUT, + + _PC_NAME_MAX, + + _PC_PATH_MAX, + + _PC_PIPE_BUF, + + _PC_CHOWN_RESTRICTED, + + _PC_NO_TRUNC, + + _PC_VDISABLE, + + _PC_SYNC_IO, + + _PC_ASYNC_IO, + + _PC_PRIO_IO, + + _PC_SOCK_MAXBUF, + + _PC_FILESIZEBITS, + + _PC_REC_INCR_XFER_SIZE, + + _PC_REC_MAX_XFER_SIZE, + + _PC_REC_MIN_XFER_SIZE, + + _PC_REC_XFER_ALIGN, + + _PC_ALLOC_SIZE_MIN, + + _PC_SYMLINK_MAX, + + _PC_2_SYMLINKS + + }; + + +enum + { + _SC_ARG_MAX, + + _SC_CHILD_MAX, + + _SC_CLK_TCK, + + _SC_NGROUPS_MAX, + + _SC_OPEN_MAX, + + _SC_STREAM_MAX, + + _SC_TZNAME_MAX, + + _SC_JOB_CONTROL, + + _SC_SAVED_IDS, + + _SC_REALTIME_SIGNALS, + + _SC_PRIORITY_SCHEDULING, + + _SC_TIMERS, + + _SC_ASYNCHRONOUS_IO, + + _SC_PRIORITIZED_IO, + + _SC_SYNCHRONIZED_IO, + + _SC_FSYNC, + + _SC_MAPPED_FILES, + + _SC_MEMLOCK, + + _SC_MEMLOCK_RANGE, + + _SC_MEMORY_PROTECTION, + + _SC_MESSAGE_PASSING, + + _SC_SEMAPHORES, + + _SC_SHARED_MEMORY_OBJECTS, + + _SC_AIO_LISTIO_MAX, + + _SC_AIO_MAX, + + _SC_AIO_PRIO_DELTA_MAX, + + _SC_DELAYTIMER_MAX, + + _SC_MQ_OPEN_MAX, + + _SC_MQ_PRIO_MAX, + + _SC_VERSION, + + _SC_PAGESIZE, + + + _SC_RTSIG_MAX, + + _SC_SEM_NSEMS_MAX, + + _SC_SEM_VALUE_MAX, + + _SC_SIGQUEUE_MAX, + + _SC_TIMER_MAX, + + + + + _SC_BC_BASE_MAX, + + _SC_BC_DIM_MAX, + + _SC_BC_SCALE_MAX, + + _SC_BC_STRING_MAX, + + _SC_COLL_WEIGHTS_MAX, + + _SC_EQUIV_CLASS_MAX, + + _SC_EXPR_NEST_MAX, + + _SC_LINE_MAX, + + _SC_RE_DUP_MAX, + + _SC_CHARCLASS_NAME_MAX, + + + _SC_2_VERSION, + + _SC_2_C_BIND, + + _SC_2_C_DEV, + + _SC_2_FORT_DEV, + + _SC_2_FORT_RUN, + + _SC_2_SW_DEV, + + _SC_2_LOCALEDEF, + + + _SC_PII, + + _SC_PII_XTI, + + _SC_PII_SOCKET, + + _SC_PII_INTERNET, + + _SC_PII_OSI, + + _SC_POLL, + + _SC_SELECT, + + _SC_UIO_MAXIOV, + + _SC_IOV_MAX =3D _SC_UIO_MAXIOV, + + _SC_PII_INTERNET_STREAM, + + _SC_PII_INTERNET_DGRAM, + + _SC_PII_OSI_COTS, + + _SC_PII_OSI_CLTS, + + _SC_PII_OSI_M, + + _SC_T_IOV_MAX, + + + + _SC_THREADS, + + _SC_THREAD_SAFE_FUNCTIONS, + + _SC_GETGR_R_SIZE_MAX, + + _SC_GETPW_R_SIZE_MAX, + + _SC_LOGIN_NAME_MAX, + + _SC_TTY_NAME_MAX, + + _SC_THREAD_DESTRUCTOR_ITERATIONS, + + _SC_THREAD_KEYS_MAX, + + _SC_THREAD_STACK_MIN, + + _SC_THREAD_THREADS_MAX, + + _SC_THREAD_ATTR_STACKADDR, + + _SC_THREAD_ATTR_STACKSIZE, + + _SC_THREAD_PRIORITY_SCHEDULING, + + _SC_THREAD_PRIO_INHERIT, + + _SC_THREAD_PRIO_PROTECT, + + _SC_THREAD_PROCESS_SHARED, + + + _SC_NPROCESSORS_CONF, + + _SC_NPROCESSORS_ONLN, + + _SC_PHYS_PAGES, + + _SC_AVPHYS_PAGES, + + _SC_ATEXIT_MAX, + + _SC_PASS_MAX, + + + _SC_XOPEN_VERSION, + + _SC_XOPEN_XCU_VERSION, + + _SC_XOPEN_UNIX, + + _SC_XOPEN_CRYPT, + + _SC_XOPEN_ENH_I18N, + + _SC_XOPEN_SHM, + + + _SC_2_CHAR_TERM, + + _SC_2_C_VERSION, + + _SC_2_UPE, + + + _SC_XOPEN_XPG2, + + _SC_XOPEN_XPG3, + + _SC_XOPEN_XPG4, + + + _SC_CHAR_BIT, + + _SC_CHAR_MAX, + + _SC_CHAR_MIN, + + _SC_INT_MAX, + + _SC_INT_MIN, + + _SC_LONG_BIT, + + _SC_WORD_BIT, + + _SC_MB_LEN_MAX, + + _SC_NZERO, + + _SC_SSIZE_MAX, + + _SC_SCHAR_MAX, + + _SC_SCHAR_MIN, + + _SC_SHRT_MAX, + + _SC_SHRT_MIN, + + _SC_UCHAR_MAX, + + _SC_UINT_MAX, + + _SC_ULONG_MAX, + + _SC_USHRT_MAX, + + + _SC_NL_ARGMAX, + + _SC_NL_LANGMAX, + + _SC_NL_MSGMAX, + + _SC_NL_NMAX, + + _SC_NL_SETMAX, + + _SC_NL_TEXTMAX, + + + _SC_XBS5_ILP32_OFF32, + + _SC_XBS5_ILP32_OFFBIG, + + _SC_XBS5_LP64_OFF64, + + _SC_XBS5_LPBIG_OFFBIG, + + + _SC_XOPEN_LEGACY, + + _SC_XOPEN_REALTIME, + + _SC_XOPEN_REALTIME_THREADS, + + + _SC_ADVISORY_INFO, + + _SC_BARRIERS, + + _SC_BASE, + + _SC_C_LANG_SUPPORT, + + _SC_C_LANG_SUPPORT_R, + + _SC_CLOCK_SELECTION, + + _SC_CPUTIME, + + _SC_THREAD_CPUTIME, + + _SC_DEVICE_IO, + + _SC_DEVICE_SPECIFIC, + + _SC_DEVICE_SPECIFIC_R, + + _SC_FD_MGMT, + + _SC_FIFO, + + _SC_PIPE, + + _SC_FILE_ATTRIBUTES, + + _SC_FILE_LOCKING, + + _SC_FILE_SYSTEM, + + _SC_MONOTONIC_CLOCK, + + _SC_MULTI_PROCESS, + + _SC_SINGLE_PROCESS, + + _SC_NETWORKING, + + _SC_READER_WRITER_LOCKS, + + _SC_SPIN_LOCKS, + + _SC_REGEXP, + + _SC_REGEX_VERSION, + + _SC_SHELL, + + _SC_SIGNALS, + + _SC_SPAWN, + + _SC_SPORADIC_SERVER, + + _SC_THREAD_SPORADIC_SERVER, + + _SC_SYSTEM_DATABASE, + + _SC_SYSTEM_DATABASE_R, + + _SC_TIMEOUTS, + + _SC_TYPED_MEMORY_OBJECTS, + + _SC_USER_GROUPS, + + _SC_USER_GROUPS_R, + + _SC_2_PBS, + + _SC_2_PBS_ACCOUNTING, + + _SC_2_PBS_LOCATE, + + _SC_2_PBS_MESSAGE, + + _SC_2_PBS_TRACK, + + _SC_SYMLOOP_MAX, + + _SC_STREAMS, + + _SC_2_PBS_CHECKPOINT, + + + _SC_V6_ILP32_OFF32, + + _SC_V6_ILP32_OFFBIG, + + _SC_V6_LP64_OFF64, + + _SC_V6_LPBIG_OFFBIG, + + + _SC_HOST_NAME_MAX, + + _SC_TRACE, + + _SC_TRACE_EVENT_FILTER, + + _SC_TRACE_INHERIT, + + _SC_TRACE_LOG, + + + _SC_LEVEL1_ICACHE_SIZE, + + _SC_LEVEL1_ICACHE_ASSOC, + + _SC_LEVEL1_ICACHE_LINESIZE, + + _SC_LEVEL1_DCACHE_SIZE, + + _SC_LEVEL1_DCACHE_ASSOC, + + _SC_LEVEL1_DCACHE_LINESIZE, + + _SC_LEVEL2_CACHE_SIZE, + + _SC_LEVEL2_CACHE_ASSOC, + + _SC_LEVEL2_CACHE_LINESIZE, + + _SC_LEVEL3_CACHE_SIZE, + + _SC_LEVEL3_CACHE_ASSOC, + + _SC_LEVEL3_CACHE_LINESIZE, + + _SC_LEVEL4_CACHE_SIZE, + + _SC_LEVEL4_CACHE_ASSOC, + + _SC_LEVEL4_CACHE_LINESIZE, + + + + _SC_IPV6 =3D _SC_LEVEL1_ICACHE_SIZE + 50, + + _SC_RAW_SOCKETS, + + + _SC_V7_ILP32_OFF32, + + _SC_V7_ILP32_OFFBIG, + + _SC_V7_LP64_OFF64, + + _SC_V7_LPBIG_OFFBIG, + + + _SC_SS_REPL_MAX, + + + _SC_TRACE_EVENT_NAME_MAX, + + _SC_TRACE_NAME_MAX, + + _SC_TRACE_SYS_MAX, + + _SC_TRACE_USER_EVENT_MAX, + + + _SC_XOPEN_STREAMS, + + + _SC_THREAD_ROBUST_PRIO_INHERIT, + + _SC_THREAD_ROBUST_PRIO_PROTECT, + + + _SC_MINSIGSTKSZ, + + + _SC_SIGSTKSZ + + }; + + +enum + { + _CS_PATH, + + + _CS_V6_WIDTH_RESTRICTED_ENVS, + + + + _CS_GNU_LIBC_VERSION, + + _CS_GNU_LIBPTHREAD_VERSION, + + + _CS_V5_WIDTH_RESTRICTED_ENVS, + + + + _CS_V7_WIDTH_RESTRICTED_ENVS, + + + + _CS_LFS_CFLAGS =3D 1000, + + _CS_LFS_LDFLAGS, + + _CS_LFS_LIBS, + + _CS_LFS_LINTFLAGS, + + _CS_LFS64_CFLAGS, + + _CS_LFS64_LDFLAGS, + + _CS_LFS64_LIBS, + + _CS_LFS64_LINTFLAGS, + + + _CS_XBS5_ILP32_OFF32_CFLAGS =3D 1100, + + _CS_XBS5_ILP32_OFF32_LDFLAGS, + + _CS_XBS5_ILP32_OFF32_LIBS, + + _CS_XBS5_ILP32_OFF32_LINTFLAGS, + + _CS_XBS5_ILP32_OFFBIG_CFLAGS, + + _CS_XBS5_ILP32_OFFBIG_LDFLAGS, + + _CS_XBS5_ILP32_OFFBIG_LIBS, + + _CS_XBS5_ILP32_OFFBIG_LINTFLAGS, + + _CS_XBS5_LP64_OFF64_CFLAGS, + + _CS_XBS5_LP64_OFF64_LDFLAGS, + + _CS_XBS5_LP64_OFF64_LIBS, + + _CS_XBS5_LP64_OFF64_LINTFLAGS, + + _CS_XBS5_LPBIG_OFFBIG_CFLAGS, + + _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, + + _CS_XBS5_LPBIG_OFFBIG_LIBS, + + _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS, + + + _CS_POSIX_V6_ILP32_OFF32_CFLAGS, + + _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, + + _CS_POSIX_V6_ILP32_OFF32_LIBS, + + _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS, + + _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, + + _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, + + _CS_POSIX_V6_ILP32_OFFBIG_LIBS, + + _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS, + + _CS_POSIX_V6_LP64_OFF64_CFLAGS, + + _CS_POSIX_V6_LP64_OFF64_LDFLAGS, + + _CS_POSIX_V6_LP64_OFF64_LIBS, + + _CS_POSIX_V6_LP64_OFF64_LINTFLAGS, + + _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, + + _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, + + _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, + + _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS, + + + _CS_POSIX_V7_ILP32_OFF32_CFLAGS, + + _CS_POSIX_V7_ILP32_OFF32_LDFLAGS, + + _CS_POSIX_V7_ILP32_OFF32_LIBS, + + _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS, + + _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS, + + _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS, + + _CS_POSIX_V7_ILP32_OFFBIG_LIBS, + + _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS, + + _CS_POSIX_V7_LP64_OFF64_CFLAGS, + + _CS_POSIX_V7_LP64_OFF64_LDFLAGS, + + _CS_POSIX_V7_LP64_OFF64_LIBS, + + _CS_POSIX_V7_LP64_OFF64_LINTFLAGS, + + _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS, + + _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS, + + _CS_POSIX_V7_LPBIG_OFFBIG_LIBS, + + _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS, + + + _CS_V6_ENV, + + _CS_V7_ENV + + }; +# 631 "/usr/include/unistd.h" 2 3 4 + + +extern long int pathconf (const char *__path, int __name) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int fpathconf (int __fd, int __name) noexcept (true); + + +extern long int sysconf (int __name) noexcept (true); + + + +extern size_t confstr (int __name, char *__buf, size_t __len) noexcept (tr= ue) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern __pid_t getpid (void) noexcept (true); + + +extern __pid_t getppid (void) noexcept (true); + + +extern __pid_t getpgrp (void) noexcept (true); + + +extern __pid_t __getpgid (__pid_t __pid) noexcept (true); + +extern __pid_t getpgid (__pid_t __pid) noexcept (true); + + + + + + +extern int setpgid (__pid_t __pid, __pid_t __pgid) noexcept (true); +# 682 "/usr/include/unistd.h" 3 4 +extern int setpgrp (void) noexcept (true); + + + + + + +extern __pid_t setsid (void) noexcept (true); + + + +extern __pid_t getsid (__pid_t __pid) noexcept (true); + + + +extern __uid_t getuid (void) noexcept (true); + + +extern __uid_t geteuid (void) noexcept (true); + + +extern __gid_t getgid (void) noexcept (true); + + +extern __gid_t getegid (void) noexcept (true); + + + + +extern int getgroups (int __size, __gid_t __list[]) noexcept (true) __attr= ibute__ ((__warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 1))); + + +extern int group_member (__gid_t __gid) noexcept (true); + + + + + + +extern int setuid (__uid_t __uid) noexcept (true) __attribute__ ((__warn_u= nused_result__)); + + + + +extern int setreuid (__uid_t __ruid, __uid_t __euid) noexcept (true) __att= ribute__ ((__warn_unused_result__)); + + + + +extern int seteuid (__uid_t __uid) noexcept (true) __attribute__ ((__warn_= unused_result__)); + + + + + + +extern int setgid (__gid_t __gid) noexcept (true) __attribute__ ((__warn_u= nused_result__)); + + + + +extern int setregid (__gid_t __rgid, __gid_t __egid) noexcept (true) __att= ribute__ ((__warn_unused_result__)); + + + + +extern int setegid (__gid_t __gid) noexcept (true) __attribute__ ((__warn_= unused_result__)); + + + + + +extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid) + noexcept (true); + + + +extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid) + noexcept (true); + + + +extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid) + noexcept (true) __attribute__ ((__warn_unused_result__)); + + + +extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid) + noexcept (true) __attribute__ ((__warn_unused_result__)); + + + + + + +extern __pid_t fork (void) noexcept (true); + + + + + + + +extern __pid_t vfork (void) noexcept (true); + + + + + + +extern __pid_t _Fork (void) noexcept (true); + + + + + +extern char *ttyname (int __fd) noexcept (true); + + + +extern int ttyname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__w= arn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + + +extern int isatty (int __fd) noexcept (true); + + + + +extern int ttyslot (void) noexcept (true); + + + + +extern int link (const char *__from, const char *__to) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((= __warn_unused_result__)); + + + + +extern int linkat (int __fromfd, const char *__from, int __tofd, + const char *__to, int __flags) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((= __warn_unused_result__)); + + + + +extern int symlink (const char *__from, const char *__to) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((= __warn_unused_result__)); + + + + +extern ssize_t readlink (const char *__restrict __path, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((= __warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + + +extern int symlinkat (const char *__from, int __tofd, + const char *__to) noexcept (true) __attribute__ ((__nonnull__ (1, = 3))) __attribute__ ((__warn_unused_result__)); + + +extern ssize_t readlinkat (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((= __warn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 3, 4))); + + + +extern int unlink (const char *__name) noexcept (true) __attribute__ ((__n= onnull__ (1))); + + + +extern int unlinkat (int __fd, const char *__name, int __flag) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern int rmdir (const char *__path) noexcept (true) __attribute__ ((__no= nnull__ (1))); + + + +extern __pid_t tcgetpgrp (int __fd) noexcept (true); + + +extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) noexcept (true); + + + + + + +extern char *getlogin (void); + + + + + + + +extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__= nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + + +extern int setlogin (const char *__name) noexcept (true) __attribute__ ((_= _nonnull__ (1))); + + + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/getopt_posix.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/getopt_posix.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/getopt_core.h" 1 3 4 +# 28 "/usr/include/riscv64-linux-gnu/bits/getopt_core.h" 3 4 +extern "C" { + + + + + + + +extern char *optarg; +# 50 "/usr/include/riscv64-linux-gnu/bits/getopt_core.h" 3 4 +extern int optind; + + + + +extern int opterr; + + + +extern int optopt; +# 91 "/usr/include/riscv64-linux-gnu/bits/getopt_core.h" 3 4 +extern int getopt (int ___argc, char *const *___argv, const char *__shorto= pts) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +} +# 28 "/usr/include/riscv64-linux-gnu/bits/getopt_posix.h" 2 3 4 + +extern "C" { +# 49 "/usr/include/riscv64-linux-gnu/bits/getopt_posix.h" 3 4 +} +# 904 "/usr/include/unistd.h" 2 3 4 + + + + + + + +extern int gethostname (char *__name, size_t __len) noexcept (true) __attr= ibute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + + + + +extern int sethostname (const char *__name, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)) __attribute__ ((__access__ (__read_only__, 1, 2))); + + + +extern int sethostid (long int __id) noexcept (true) __attribute__ ((__war= n_unused_result__)); + + + + + +extern int getdomainname (char *__name, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)) + __attribute__ ((__access__ (__write_only__, 1, 2))); +extern int setdomainname (const char *__name, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)) __attribute__ ((__access__ (__read_only__, 1, 2))); + + + + +extern int vhangup (void) noexcept (true); + + +extern int revoke (const char *__file) noexcept (true) __attribute__ ((__n= onnull__ (1))) __attribute__ ((__warn_unused_result__)); + + + + + + + +extern int profil (unsigned short int *__sample_buffer, size_t __size, + size_t __offset, unsigned int __scale) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int acct (const char *__name) noexcept (true); + + + +extern char *getusershell (void) noexcept (true); +extern void endusershell (void) noexcept (true); +extern void setusershell (void) noexcept (true); + + + + + +extern int daemon (int __nochdir, int __noclose) noexcept (true) __attribu= te__ ((__warn_unused_result__)); + + + + + + +extern int chroot (const char *__path) noexcept (true) __attribute__ ((__n= onnull__ (1))) __attribute__ ((__warn_unused_result__)); + + + +extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1= ))); + + + + + + + +extern int fsync (int __fd); + + + + + +extern int syncfs (int __fd) noexcept (true); + + + + + + +extern long int gethostid (void); + + +extern void sync (void) noexcept (true); + + + + + +extern int getpagesize (void) noexcept (true) __attribute__ ((__const__)); + + + + +extern int getdtablesize (void) noexcept (true); +# 1026 "/usr/include/unistd.h" 3 4 +extern int truncate (const char *__file, __off_t __length) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)); +# 1038 "/usr/include/unistd.h" 3 4 +extern int truncate64 (const char *__file, __off64_t __length) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)); +# 1049 "/usr/include/unistd.h" 3 4 +extern int ftruncate (int __fd, __off_t __length) noexcept (true) __attrib= ute__ ((__warn_unused_result__)); +# 1059 "/usr/include/unistd.h" 3 4 +extern int ftruncate64 (int __fd, __off64_t __length) noexcept (true) __at= tribute__ ((__warn_unused_result__)); +# 1070 "/usr/include/unistd.h" 3 4 +extern int brk (void *__addr) noexcept (true) __attribute__ ((__warn_unuse= d_result__)); + + + + + +extern void *sbrk (intptr_t __delta) noexcept (true); +# 1091 "/usr/include/unistd.h" 3 4 +extern long int syscall (long int __sysno, ...) noexcept (true); +# 1114 "/usr/include/unistd.h" 3 4 +extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__wa= rn_unused_result__)); +# 1124 "/usr/include/unistd.h" 3 4 +extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((= __warn_unused_result__)); +# 1142 "/usr/include/unistd.h" 3 4 +ssize_t copy_file_range (int __infd, __off64_t *__pinoff, + int __outfd, __off64_t *__poutoff, + size_t __length, unsigned int __flags); + + + + + +extern int fdatasync (int __fildes); +# 1159 "/usr/include/unistd.h" 3 4 +extern char *crypt (const char *__key, const char *__salt) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + + + +extern void swab (const void *__restrict __from, void *__restrict __to, + ssize_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))) + __attribute__ ((__access__ (__read_only__, 1, 3))) + __attribute__ ((__access__ (__write_only__, 2, 3))); +# 1198 "/usr/include/unistd.h" 3 4 +int getentropy (void *__buffer, size_t __length) __attribute__ ((__warn_un= used_result__)) + __attribute__ ((__access__ (__write_only__, 1, 2))); +# 1208 "/usr/include/unistd.h" 3 4 +extern int close_range (unsigned int __fd, unsigned int __max_fd, + int __flags) noexcept (true); + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/unistd.h" 1 3 4 +# 23 "/usr/include/riscv64-linux-gnu/bits/unistd.h" 3 4 +extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes, + size_t __buflen) + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm= __ ("" "read") + + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, si= ze_t __buflen) __asm__ ("" "__read_chk") + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "read called with bigger length than size of " "the destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) ssize_t +read (int __fd, void *__buf, size_t __nbytes) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 0)) && (__= builtin_object_size (__buf, 0)) =3D=3D (long unsigned int) -1) || (((__type= of (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_constant_p (__nby= tes) && (__nbytes) > 0)) && __builtin_constant_p ((((long unsigned int) (__= nbytes)) <=3D ((__builtin_object_size (__buf, 0))) / ((sizeof (char))))) &&= (((long unsigned int) (__nbytes)) <=3D ((__builtin_object_size (__buf, 0))= ) / ((sizeof (char)))))) ? __read_alias (__fd, __buf, __nbytes) : ((((__typ= eof (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_constant_p (__nb= ytes) && (__nbytes) > 0)) && __builtin_constant_p ((((long unsigned int) (_= _nbytes)) <=3D (__builtin_object_size (__buf, 0)) / (sizeof (char)))) && !(= ((long unsigned int) (__nbytes)) <=3D (__builtin_object_size (__buf, 0)) / = (sizeof (char)))) ? __read_chk_warn (__fd, __buf, __nbytes, __builtin_objec= t_size (__buf, 0)) : __read_chk (__fd, __buf, __nbytes, __builtin_object_si= ze (__buf, 0)))) + + ; +} + + +extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, + __off_t __offset, size_t __bufsize) + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset, size_t __bufsize) + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __of= f_t __offset) __asm__ ("" "pread") + + + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __= off64_t __offset) __asm__ ("" "pread64") + + + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 2, 3))); +extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, _= _off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk") + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "pread called with bigger length than size of " "the destination buffer"))) + ; +extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes,= __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk") + + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "pread64 called with bigger length than size of " "the destination buffer")= )) + ; + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) ssize_t +pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 0)) && (__= builtin_object_size (__buf, 0)) =3D=3D (long unsigned int) -1) || (((__type= of (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_constant_p (__nby= tes) && (__nbytes) > 0)) && __builtin_constant_p ((((long unsigned int) (__= nbytes)) <=3D ((__builtin_object_size (__buf, 0))) / ((sizeof (char))))) &&= (((long unsigned int) (__nbytes)) <=3D ((__builtin_object_size (__buf, 0))= ) / ((sizeof (char)))))) ? __pread_alias (__fd, __buf, __nbytes, __offset) = : ((((__typeof (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_const= ant_p (__nbytes) && (__nbytes) > 0)) && __builtin_constant_p ((((long unsig= ned int) (__nbytes)) <=3D (__builtin_object_size (__buf, 0)) / (sizeof (cha= r)))) && !(((long unsigned int) (__nbytes)) <=3D (__builtin_object_size (__= buf, 0)) / (sizeof (char)))) ? __pread_chk_warn (__fd, __buf, __nbytes, __o= ffset, __builtin_object_size (__buf, 0)) : __pread_chk (__fd, __buf, __nbyt= es, __offset, __builtin_object_size (__buf, 0)))) + + ; +} +# 89 "/usr/include/riscv64-linux-gnu/bits/unistd.h" 3 4 +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) ssize_t +pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 0)) && (__= builtin_object_size (__buf, 0)) =3D=3D (long unsigned int) -1) || (((__type= of (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_constant_p (__nby= tes) && (__nbytes) > 0)) && __builtin_constant_p ((((long unsigned int) (__= nbytes)) <=3D ((__builtin_object_size (__buf, 0))) / ((sizeof (char))))) &&= (((long unsigned int) (__nbytes)) <=3D ((__builtin_object_size (__buf, 0))= ) / ((sizeof (char)))))) ? __pread64_alias (__fd, __buf, __nbytes, __offset= ) : ((((__typeof (__nbytes)) 0 < (__typeof (__nbytes)) -1 || (__builtin_con= stant_p (__nbytes) && (__nbytes) > 0)) && __builtin_constant_p ((((long uns= igned int) (__nbytes)) <=3D (__builtin_object_size (__buf, 0)) / (sizeof (c= har)))) && !(((long unsigned int) (__nbytes)) <=3D (__builtin_object_size (= __buf, 0)) / (sizeof (char)))) ? __pread64_chk_warn (__fd, __buf, __nbytes,= __offset, __builtin_object_size (__buf, 0)) : __pread64_chk (__fd, __buf, = __nbytes, __offset, __builtin_object_size (__buf, 0)))) + + ; +} + + + + +extern ssize_t __readlink_chk (const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((= __warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 2, 3))= ); +extern ssize_t __readlink_alias (const char *__restrict __path, char *__re= strict __buf, size_t __len) noexcept (true) __asm__ ("" "readlink") + + + __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_re= sult__)) __attribute__ ((__access__ (__write_only__, 2, 3))); +extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *_= _restrict __buf, size_t __len, size_t __buflen) noexcept (true) __asm__ (""= "__readlink_chk") + + + + __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_re= sult__)) __attribute__((__warning__ ("readlink called with bigger length " = "than size of destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1,= 2))) __attribute__ ((__warn_unused_result__)) ssize_t +__attribute__ ((__leaf__)) readlink (const char *__restrict __path, char *= __restrict __buf, size_t __len) noexcept (true) + +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__buf, 2 > 1))) = / ((sizeof (char)))))) ? __readlink_alias (__path, __buf, __len) : ((((__ty= peof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) &&= (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <=3D= (__builtin_object_size (__buf, 2 > 1)) / (sizeof (char)))) && !(((long uns= igned int) (__len)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (sizeof (= char)))) ? __readlink_chk_warn (__path, __buf, __len, __builtin_object_size= (__buf, 2 > 1)) : __readlink_chk (__path, __buf, __len, __builtin_object_s= ize (__buf, 2 > 1)))) + + ; +} + + + +extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((= __warn_unused_result__)) __attribute__ ((__access__ (__write_only__, 3, 4))= ); +extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path= , char *__restrict __buf, size_t __len) noexcept (true) __asm__ ("" "readli= nkat") + + + + __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_re= sult__)) __attribute__ ((__access__ (__write_only__, 3, 4))); +extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __p= ath, char *__restrict __buf, size_t __len, size_t __buflen) noexcept (true)= __asm__ ("" "__readlinkat_chk") + + + + __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_re= sult__)) __attribute__((__warning__ ("readlinkat called with bigger " "leng= th than size of destination " "buffer"))) + + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2,= 3))) __attribute__ ((__warn_unused_result__)) ssize_t +__attribute__ ((__leaf__)) readlinkat (int __fd, const char *__restrict __= path, char *__restrict __buf, size_t __len) noexcept (true) + +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__buf, 2 > 1))) = / ((sizeof (char)))))) ? __readlinkat_alias (__fd, __path, __buf, __len) : = ((((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (_= _len) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__le= n)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (sizeof (char)))) && !(((= long unsigned int) (__len)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (= sizeof (char)))) ? __readlinkat_chk_warn (__fd, __path, __buf, __len, __bui= ltin_object_size (__buf, 2 > 1)) : __readlinkat_chk (__fd, __path, __buf, _= _len, __builtin_object_size (__buf, 2 > 1)))) + + ; +} + + +extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen) + noexcept (true) __attribute__ ((__warn_unused_result__)); +extern char *__getcwd_alias (char *__buf, size_t __size) noexcept (true) _= _asm__ ("" "getcwd") + __attribute__ ((__warn_unuse= d_result__)); +extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __bufle= n) noexcept (true) __asm__ ("" "__getcwd_chk") + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "getcwd caller with bigger length than size of " "destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_r= esult__)) char * +__attribute__ ((__leaf__)) getcwd (char *__buf, size_t __size) noexcept (t= rue) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__size)) 0 < (__typeof (__size)) -1 || (__builtin_constant_p (_= _size) && (__size) > 0)) && __builtin_constant_p ((((long unsigned int) (__= size)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (char))))) = && (((long unsigned int) (__size)) <=3D ((__builtin_object_size (__buf, 2 >= 1))) / ((sizeof (char)))))) ? __getcwd_alias (__buf, __size) : ((((__typeo= f (__size)) 0 < (__typeof (__size)) -1 || (__builtin_constant_p (__size) &&= (__size) > 0)) && __builtin_constant_p ((((long unsigned int) (__size)) <= =3D (__builtin_object_size (__buf, 2 > 1)) / (sizeof (char)))) && !(((long = unsigned int) (__size)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (size= of (char)))) ? __getcwd_chk_warn (__buf, __size, __builtin_object_size (__b= uf, 2 > 1)) : __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 = > 1)))) + + ; +} + + +extern char *__getwd_chk (char *__buf, size_t buflen) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); +extern char *__getwd_warn (char *__buf) noexcept (true) __asm__ ("" "getwd= ") + __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_resul= t__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "d= oesn't specify buffer size"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1)= )) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)= ) char * +__attribute__ ((__leaf__)) getwd (char *__buf) noexcept (true) +{ + if (__builtin_object_size (__buf, 2 > 1) !=3D (size_t) -1) + return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1)); + return __getwd_warn (__buf); +} + + +extern size_t __confstr_chk (int __name, char *__buf, size_t __len, + size_t __buflen) noexcept (true) + __attribute__ ((__access__ (__write_only__, 2, 3))); +extern size_t __confstr_alias (int __name, char *__buf, size_t __len) noex= cept (true) __asm__ ("" "confstr") + + __attribute__ ((__access__ (__write_only__, 2, 3))); +extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, s= ize_t __buflen) noexcept (true) __asm__ ("" "__confstr_chk") + + + __attribute__((__warning__ ("confstr called with bigger length than s= ize of destination " "buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) size_t +__attribute__ ((__leaf__)) confstr (int __name, char *__buf, size_t __len)= noexcept (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__l= en) && (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)= ) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (char))))) && ((= (long unsigned int) (__len)) <=3D ((__builtin_object_size (__buf, 2 > 1))) = / ((sizeof (char)))))) ? __confstr_alias (__name, __buf, __len) : ((((__typ= eof (__len)) 0 < (__typeof (__len)) -1 || (__builtin_constant_p (__len) && = (__len) > 0)) && __builtin_constant_p ((((long unsigned int) (__len)) <=3D = (__builtin_object_size (__buf, 2 > 1)) / (sizeof (char)))) && !(((long unsi= gned int) (__len)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (sizeof (c= har)))) ? __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (= __buf, 2 > 1)) : __confstr_chk (__name, __buf, __len, __builtin_object_size= (__buf, 2 > 1)))) + + ; +} + + +extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ (= (__access__ (__write_only__, 2, 1))); +extern int __getgroups_alias (int __size, __gid_t __list[]) noexcept (true= ) __asm__ ("" "getgroups") + __attribute__ ((__warn_unused_result__)) __attribute__ ((= __access__ (__write_only__, 2, 1))); +extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __li= stlen) noexcept (true) __asm__ ("" "__getgroups_chk") + + + __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ (= "getgroups called with bigger group count than what " "can fit into destina= tion buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) getgroups (int __size, __gid_t __list[]) noexce= pt (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__list, 2 > 1)) &= & (__builtin_object_size (__list, 2 > 1)) =3D=3D (long unsigned int) -1) ||= (((__typeof (__size)) 0 < (__typeof (__size)) -1 || (__builtin_constant_p = (__size) && (__size) > 0)) && __builtin_constant_p ((((long unsigned int) (= __size)) <=3D ((__builtin_object_size (__list, 2 > 1))) / ((sizeof (__gid_t= ))))) && (((long unsigned int) (__size)) <=3D ((__builtin_object_size (__li= st, 2 > 1))) / ((sizeof (__gid_t)))))) ? __getgroups_alias (__size, __list)= : ((((__typeof (__size)) 0 < (__typeof (__size)) -1 || (__builtin_constant= _p (__size) && (__size) > 0)) && __builtin_constant_p ((((long unsigned int= ) (__size)) <=3D (__builtin_object_size (__list, 2 > 1)) / (sizeof (__gid_t= )))) && !(((long unsigned int) (__size)) <=3D (__builtin_object_size (__lis= t, 2 > 1)) / (sizeof (__gid_t)))) ? __getgroups_chk_warn (__size, __list, _= _builtin_object_size (__list, 2 > 1)) : __getgroups_chk (__size, __list, __= builtin_object_size (__list, 2 > 1)))) + + ; +} + + +extern int __ttyname_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 __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) noex= cept (true) __asm__ ("" "ttyname_r") + + __attribute__ ((__nonnull__ (2))); +extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, s= ize_t __nreal) noexcept (true) __asm__ ("" "__ttyname_r_chk") + + + __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttynam= e_r called with bigger buflen than " "size of destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) ttyname_r (int __fd, char *__buf, size_t __bufl= en) noexcept (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_= p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned = int) (__buflen)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (= char))))) && (((long unsigned int) (__buflen)) <=3D ((__builtin_object_size= (__buf, 2 > 1))) / ((sizeof (char)))))) ? __ttyname_r_alias (__fd, __buf, = __buflen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__bui= ltin_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((= long unsigned int) (__buflen)) <=3D (__builtin_object_size (__buf, 2 > 1)) = / (sizeof (char)))) && !(((long unsigned int) (__buflen)) <=3D (__builtin_o= bject_size (__buf, 2 > 1)) / (sizeof (char)))) ? __ttyname_r_chk_warn (__fd= , __buf, __buflen, __builtin_object_size (__buf, 2 > 1)) : __ttyname_r_chk = (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1)))) + + ; +} + + + +extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal) + __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__write= _only__, 1, 2))); +extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "= getlogin_r") + __attribute__ ((__nonnull__ (1))); +extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __n= real) __asm__ ("" "__getlogin_r_chk") + + + __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlog= in_r called with bigger buflen than " "size of destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +getlogin_r (char *__buf, size_t __buflen) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_= p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned = int) (__buflen)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (= char))))) && (((long unsigned int) (__buflen)) <=3D ((__builtin_object_size= (__buf, 2 > 1))) / ((sizeof (char)))))) ? __getlogin_r_alias (__buf, __buf= len) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_= constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long = unsigned int) (__buflen)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (si= zeof (char)))) && !(((long unsigned int) (__buflen)) <=3D (__builtin_object= _size (__buf, 2 > 1)) / (sizeof (char)))) ? __getlogin_r_chk_warn (__buf, _= _buflen, __builtin_object_size (__buf, 2 > 1)) : __getlogin_r_chk (__buf, _= _buflen, __builtin_object_size (__buf, 2 > 1)))) + + ; +} + + + + +extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__a= ccess__ (__write_only__, 1, 2))); +extern int __gethostname_alias (char *__buf, size_t __buflen) noexcept (tr= ue) __asm__ ("" "gethostname") + + __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__write_on= ly__, 1, 2))); +extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __= nreal) noexcept (true) __asm__ ("" "__gethostname_chk") + + + __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethos= tname called with bigger buflen than " "size of destination buffer"))) + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) gethostname (char *__buf, size_t __buflen) noex= cept (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_= p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned = int) (__buflen)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (= char))))) && (((long unsigned int) (__buflen)) <=3D ((__builtin_object_size= (__buf, 2 > 1))) / ((sizeof (char)))))) ? __gethostname_alias (__buf, __bu= flen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin= _constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long= unsigned int) (__buflen)) <=3D (__builtin_object_size (__buf, 2 > 1)) / (s= izeof (char)))) && !(((long unsigned int) (__buflen)) <=3D (__builtin_objec= t_size (__buf, 2 > 1)) / (sizeof (char)))) ? __gethostname_chk_warn (__buf,= __buflen, __builtin_object_size (__buf, 2 > 1)) : __gethostname_chk (__buf= , __buflen, __builtin_object_size (__buf, 2 > 1)))) + + ; +} + + + + +extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nre= al) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__w= arn_unused_result__)) __attribute__ ((__access__ (__write_only__, 1, 2))); +extern int __getdomainname_alias (char *__buf, size_t __buflen) noexcept (= true) __asm__ ("" "getdomainname") + + __attribute__ ((__nonnull__ (1))) + __attribute__ ((__warn_unused_result__)) __attribute__ ((__access__ (__w= rite_only__, 1, 2))); +extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t = __nreal) noexcept (true) __asm__ ("" "__getdomainname_chk") + + + __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_resul= t__)) __attribute__((__warning__ ("getdomainname called with bigger " "bufl= en than size of destination " "buffer"))) + + ; + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_= inline__)) __attribute__ ((__artificial__)) int +__attribute__ ((__leaf__)) getdomainname (char *__buf, size_t __buflen) no= except (true) +{ + return (((__builtin_constant_p (__builtin_object_size (__buf, 2 > 1)) &&= (__builtin_object_size (__buf, 2 > 1)) =3D=3D (long unsigned int) -1) || (= ((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__builtin_constant_= p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((long unsigned = int) (__buflen)) <=3D ((__builtin_object_size (__buf, 2 > 1))) / ((sizeof (= char))))) && (((long unsigned int) (__buflen)) <=3D ((__builtin_object_size= (__buf, 2 > 1))) / ((sizeof (char)))))) ? __getdomainname_alias (__buf, __= buflen) : ((((__typeof (__buflen)) 0 < (__typeof (__buflen)) -1 || (__built= in_constant_p (__buflen) && (__buflen) > 0)) && __builtin_constant_p ((((lo= ng unsigned int) (__buflen)) <=3D (__builtin_object_size (__buf, 2 > 1)) / = (sizeof (char)))) && !(((long unsigned int) (__buflen)) <=3D (__builtin_obj= ect_size (__buf, 2 > 1)) / (sizeof (char)))) ? __getdomainname_chk_warn (__= buf, __buflen, __builtin_object_size (__buf, 2 > 1)) : __getdomainname_chk = (__buf, __buflen, __builtin_object_size (__buf, 2 > 1)))) + + ; +} +# 1215 "/usr/include/unistd.h" 2 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/unistd_ext.h" 1 3 4 +# 34 "/usr/include/riscv64-linux-gnu/bits/unistd_ext.h" 3 4 +extern __pid_t gettid (void) noexcept (true); + + + +# 1 "/usr/include/linux/close_range.h" 1 3 4 +# 39 "/usr/include/riscv64-linux-gnu/bits/unistd_ext.h" 2 3 4 +# 1219 "/usr/include/unistd.h" 2 3 4 + +} +# 374 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 399 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/regex.h" 1 3 4 +# 27 "/usr/include/regex.h" 3 4 +extern "C" { +# 55 "/usr/include/regex.h" 3 4 +typedef unsigned int __re_size_t; +typedef unsigned long int __re_long_size_t; + + + + + + + +typedef long int s_reg_t; +typedef unsigned long int active_reg_t; + + + + + + +typedef unsigned long int reg_syntax_t; +# 211 "/usr/include/regex.h" 3 4 +extern reg_syntax_t re_syntax_options; +# 346 "/usr/include/regex.h" 3 4 +typedef enum +{ + _REG_ENOSYS =3D -1, + _REG_NOERROR =3D 0, + _REG_NOMATCH, + + + + _REG_BADPAT, + _REG_ECOLLATE, + _REG_ECTYPE, + _REG_EESCAPE, + _REG_ESUBREG, + _REG_EBRACK, + _REG_EPAREN, + _REG_EBRACE, + _REG_BADBR, + _REG_ERANGE, + _REG_ESPACE, + _REG_BADRPT, + + + _REG_EEND, + _REG_ESIZE, + _REG_ERPAREN +} reg_errcode_t; +# 413 "/usr/include/regex.h" 3 4 +struct re_pattern_buffer +{ + + + struct re_dfa_t *buffer; + + + __re_long_size_t allocated; + + + __re_long_size_t used; + + + reg_syntax_t syntax; + + + + + char *fastmap; + + + + + + unsigned char * translate; + + + size_t re_nsub; + + + + + + unsigned can_be_null : 1; +# 457 "/usr/include/regex.h" 3 4 + unsigned regs_allocated : 2; + + + + unsigned fastmap_accurate : 1; + + + + unsigned no_sub : 1; + + + + unsigned not_bol : 1; + + + unsigned not_eol : 1; + + + unsigned newline_anchor : 1; +}; + +typedef struct re_pattern_buffer regex_t; +# 490 "/usr/include/regex.h" 3 4 +typedef int regoff_t; + + + + + + +struct re_registers +{ + __re_size_t num_regs; + regoff_t *start; + regoff_t *end; +}; +# 517 "/usr/include/regex.h" 3 4 +typedef struct +{ + regoff_t rm_so; + regoff_t rm_eo; +} regmatch_t; +# 535 "/usr/include/regex.h" 3 4 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wvla" +# 552 "/usr/include/regex.h" 3 4 +extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax); +# 562 "/usr/include/regex.h" 3 4 +extern const char *re_compile_pattern (const char *__pattern, size_t __len= gth, + struct re_pattern_buffer *__buffer) + __attribute__ ((__access__ (__read_only__, 1, 2))); + + + + + +extern int re_compile_fastmap (struct re_pattern_buffer *__buffer); + + + + + + + +extern regoff_t re_search (struct re_pattern_buffer *__buffer, + const char *__String, regoff_t __length, + regoff_t __start, regoff_t __range, + struct re_registers *__regs) + __attribute__ ((__access__ (__read_only__, 2, 3))); + + + + +extern regoff_t re_search_2 (struct re_pattern_buffer *__buffer, + const char *__string1, regoff_t __length1, + const char *__string2, regoff_t __length2, + regoff_t __start, regoff_t __range, + struct re_registers *__regs, + regoff_t __stop) + __attribute__ ((__access__ (__read_only__, 2, 3))) + __attribute__ ((__access__ (__read_only__, 4, 5))); + + + + +extern regoff_t re_match (struct re_pattern_buffer *__buffer, + const char *__String, regoff_t __length, + regoff_t __start, struct re_registers *__regs) + __attribute__ ((__access__ (__read_only__, 2, 3))); + + + +extern regoff_t re_match_2 (struct re_pattern_buffer *__buffer, + const char *__string1, regoff_t __length1, + const char *__string2, regoff_t __length2, + regoff_t __start, struct re_registers *__regs, + regoff_t __stop) + __attribute__ ((__access__ (__read_only__, 2, 3))) + __attribute__ ((__access__ (__read_only__, 4, 5))); +# 627 "/usr/include/regex.h" 3 4 +extern void re_set_registers (struct re_pattern_buffer *__buffer, + struct re_registers *__regs, + __re_size_t __num_regs, + regoff_t *__starts, regoff_t *__ends); +# 675 "/usr/include/regex.h" 3 4 +extern int regcomp (regex_t *__restrict __preg, + const char *__restrict __pattern, + int __cflags); + +extern int regexec (const regex_t *__restrict __preg, + const char *__restrict __String, size_t __nmatch, + regmatch_t __pmatch[ + ], + int __eflags); + +extern size_t regerror (int __errcode, const regex_t *__restrict __preg, + char *__restrict __errbuf, size_t __errbuf_size) + __attribute__ ((__access__ (__write_only__, 3, 4))); + +extern void regfree (regex_t *__preg); + + +#pragma GCC diagnostic pop + + + +} +# 400 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 731 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/c++/13/condition_variable" 1 3 4 +# 32 "/usr/include/c++/13/condition_variable" 3 4 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/condition_variable" 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/chrono.h" 1 3 +# 33 "/usr/include/c++/13/bits/chrono.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/chrono.h" 3 + + + +# 1 "/usr/include/c++/13/ratio" 1 3 +# 33 "/usr/include/c++/13/ratio" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/ratio" 3 +# 42 "/usr/include/c++/13/ratio" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/13/ratio" 3 + template + struct __static_sign + : integral_constant + { }; + + template + struct __static_abs + : integral_constant::value> + { }; + + template + struct __static_gcd + : __static_gcd<_Qn, (_Pn % _Qn)> + { }; + + template + struct __static_gcd<_Pn, 0> + : integral_constant::value> + { }; + + template + struct __static_gcd<0, _Qn> + : integral_constant::value> + { }; + + + + + + + + template + struct __safe_multiply + { + private: + static const uintmax_t __c =3D uintmax_t(1) << (sizeof(intmax_t) * 4= ); + + static const uintmax_t __a0 =3D __static_abs<_Pn>::value % __c; + static const uintmax_t __a1 =3D __static_abs<_Pn>::value / __c; + static const uintmax_t __b0 =3D __static_abs<_Qn>::value % __c; + static const uintmax_t __b1 =3D __static_abs<_Qn>::value / __c; + + static_assert(__a1 =3D=3D 0 || __b1 =3D=3D 0, + "overflow in multiplication"); + static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), + "overflow in multiplication"); + static_assert(__b0 * __a0 <=3D 0x7fffffffffffffffL, + "overflow in multiplication"); + static_assert((__a0 * __b1 + __b0 * __a1) * __c + <=3D 0x7fffffffffffffffL - __b0 * __a0, + "overflow in multiplication"); + + public: + static const intmax_t value =3D _Pn * _Qn; + }; + + + + template + struct __big_less + : integral_constant + { }; + + template + struct __big_add + { + static constexpr uintmax_t __lo =3D __lo1 + __lo2; + static constexpr uintmax_t __hi =3D (__hi1 + __hi2 + + (__lo1 + __lo2 < __lo1)); + }; + + + template + struct __big_sub + { + static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value, + "Internal library error"); + static constexpr uintmax_t __lo =3D __lo1 - __lo2; + static constexpr uintmax_t __hi =3D (__hi1 - __hi2 - + (__lo1 < __lo2)); + }; + + + template + struct __big_mul + { + private: + static constexpr uintmax_t __c =3D uintmax_t(1) << (sizeof(intmax_t)= * 4); + static constexpr uintmax_t __x0 =3D __x % __c; + static constexpr uintmax_t __x1 =3D __x / __c; + static constexpr uintmax_t __y0 =3D __y % __c; + static constexpr uintmax_t __y1 =3D __y / __c; + static constexpr uintmax_t __x0y0 =3D __x0 * __y0; + static constexpr uintmax_t __x0y1 =3D __x0 * __y1; + static constexpr uintmax_t __x1y0 =3D __x1 * __y0; + static constexpr uintmax_t __x1y1 =3D __x1 * __y1; + static constexpr uintmax_t __mix =3D __x0y1 + __x1y0; + static constexpr uintmax_t __mix_lo =3D __mix * __c; + static constexpr uintmax_t __mix_hi + =3D __mix / __c + ((__mix < __x0y1) ? __c : 0); + typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res; + public: + static constexpr uintmax_t __hi =3D _Res::__hi; + static constexpr uintmax_t __lo =3D _Res::__lo; + }; + + + + template + struct __big_div_impl + { + private: + static_assert(__d >=3D (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)), + "Internal library error"); + static_assert(__n1 < __d, "Internal library error"); + static constexpr uintmax_t __c =3D uintmax_t(1) << (sizeof(intmax_t)= * 4); + static constexpr uintmax_t __d1 =3D __d / __c; + static constexpr uintmax_t __d0 =3D __d % __c; + + static constexpr uintmax_t __q1x =3D __n1 / __d1; + static constexpr uintmax_t __r1x =3D __n1 % __d1; + static constexpr uintmax_t __m =3D __q1x * __d0; + static constexpr uintmax_t __r1y =3D __r1x * __c + __n0 / __c; + static constexpr uintmax_t __r1z =3D __r1y + __d; + static constexpr uintmax_t __r1 + =3D ((__r1y < __m) ? ((__r1z >=3D __d) && (__r1z < __m)) + ? (__r1z + __d) : __r1z : __r1y) - __m; + static constexpr uintmax_t __q1 + =3D __q1x - ((__r1y < __m) + ? ((__r1z >=3D __d) && (__r1z < __m)) ? 2 : 1 : 0); + static constexpr uintmax_t __q0x =3D __r1 / __d1; + static constexpr uintmax_t __r0x =3D __r1 % __d1; + static constexpr uintmax_t __n =3D __q0x * __d0; + static constexpr uintmax_t __r0y =3D __r0x * __c + __n0 % __c; + static constexpr uintmax_t __r0z =3D __r0y + __d; + static constexpr uintmax_t __r0 + =3D ((__r0y < __n) ? ((__r0z >=3D __d) && (__r0z < __n)) + ? (__r0z + __d) : __r0z : __r0y) - __n; + static constexpr uintmax_t __q0 + =3D __q0x - ((__r0y < __n) ? ((__r0z >=3D __d) + && (__r0z < __n)) ? 2 : 1 : 0); + + public: + static constexpr uintmax_t __quot =3D __q1 * __c + __q0; + static constexpr uintmax_t __rem =3D __r0; + + private: + typedef __big_mul<__quot, __d> _Prod; + typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum; + static_assert(_Sum::__hi =3D=3D __n1 && _Sum::__lo =3D=3D __n0, + "Internal library error"); + }; + + template + struct __big_div + { + private: + static_assert(__d !=3D 0, "Internal library error"); + static_assert(sizeof (uintmax_t) =3D=3D sizeof (unsigned long long), + "This library calls __builtin_clzll on uintmax_t, which " + "is unsafe on your platform. Please complain to " + "http://gcc.gnu.org/bugzilla/"); + static constexpr int __shift =3D __builtin_clzll(__d); + static constexpr int __coshift_ =3D sizeof(uintmax_t) * 8 - __shift; + static constexpr int __coshift =3D (__shift !=3D 0) ? __coshift_ : 0; + static constexpr uintmax_t __c1 =3D uintmax_t(1) << __shift; + static constexpr uintmax_t __c2 =3D uintmax_t(1) << __coshift; + static constexpr uintmax_t __new_d =3D __d * __c1; + static constexpr uintmax_t __new_n0 =3D __n0 * __c1; + static constexpr uintmax_t __n1_shifted =3D (__n1 % __d) * __c1; + static constexpr uintmax_t __n0_top =3D (__shift !=3D 0) ? (__n0 / _= _c2) : 0; + static constexpr uintmax_t __new_n1 =3D __n1_shifted + __n0_top; + typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res; + + public: + static constexpr uintmax_t __quot_hi =3D __n1 / __d; + static constexpr uintmax_t __quot_lo =3D _Res::__quot; + static constexpr uintmax_t __rem =3D _Res::__rem / __c1; + + private: + typedef __big_mul<__quot_lo, __d> _P0; + typedef __big_mul<__quot_hi, __d> _P1; + typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum; + + static_assert(_P1::__hi =3D=3D 0, "Internal library error"); + static_assert(_Sum::__hi >=3D _P0::__hi, "Internal library error"); + + static_assert(_Sum::__hi =3D=3D __n1 && _Sum::__lo =3D=3D __n0, + "Internal library error"); + static_assert(__rem < __d, "Internal library error"); + }; +# 265 "/usr/include/c++/13/ratio" 3 + template + struct ratio + { + static_assert(_Den !=3D 0, "denominator cannot be zero"); + static_assert(_Num >=3D -0x7fffffffffffffffL && _Den >=3D -0x7ffffff= fffffffffL, + "out of range"); + + + static constexpr intmax_t num =3D + _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::valu= e; + + static constexpr intmax_t den =3D + __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value; + + typedef ratio type; + }; +# 292 "/usr/include/c++/13/ratio" 3 + template + struct __ratio_multiply + { + private: + static const intmax_t __gcd1 =3D + __static_gcd<_R1::num, _R2::den>::value; + static const intmax_t __gcd2 =3D + __static_gcd<_R2::num, _R1::den>::value; + + public: + typedef ratio< + __safe_multiply<(_R1::num / __gcd1), + (_R2::num / __gcd2)>::value, + __safe_multiply<(_R1::den / __gcd2), + (_R2::den / __gcd1)>::value> type; + + static constexpr intmax_t num =3D type::num; + static constexpr intmax_t den =3D type::den; + }; +# 323 "/usr/include/c++/13/ratio" 3 + template + using ratio_multiply =3D typename __ratio_multiply<_R1, _R2>::type; + + + + template + struct __ratio_divide + { + static_assert(_R2::num !=3D 0, "division by 0"); + + typedef typename __ratio_multiply< + _R1, + ratio<_R2::den, _R2::num>>::type type; + + static constexpr intmax_t num =3D type::num; + static constexpr intmax_t den =3D type::den; + }; +# 352 "/usr/include/c++/13/ratio" 3 + template + using ratio_divide =3D typename __ratio_divide<_R1, _R2>::type; + + + template + struct ratio_equal + : integral_constant + { }; + + + template + struct ratio_not_equal + : integral_constant::value> + { }; + + + + + template, + typename _Right =3D __big_mul<_R2::num,_R1::den> > + struct __ratio_less_impl_1 + : integral_constant::value> + { }; + + template::value + !=3D __static_sign<_R2::num>::value)), + bool =3D (__static_sign<_R1::num>::value =3D=3D -1 + && __static_sign<_R2::num>::value =3D=3D -1)> + struct __ratio_less_impl + : __ratio_less_impl_1<_R1, _R2>::type + { }; + + template + struct __ratio_less_impl<_R1, _R2, true, false> + : integral_constant + { }; + + template + struct __ratio_less_impl<_R1, _R2, false, true> + : __ratio_less_impl_1, + ratio<-_R1::num, _R1::den> >::type + { }; + + + + + template + struct ratio_less + : __ratio_less_impl<_R1, _R2>::type + { }; + + + template + struct ratio_less_equal + : integral_constant::value> + { }; + + + template + struct ratio_greater + : integral_constant::value> + { }; + + + template + struct ratio_greater_equal + : integral_constant::value> + { }; + + + template + inline constexpr bool ratio_equal_v =3D ratio_equal<_R1, _R2>::value; + template + inline constexpr bool ratio_not_equal_v =3D ratio_not_equal<_R1, _R2>:= :value; + template + inline constexpr bool ratio_less_v =3D ratio_less<_R1, _R2>::value; + template + inline constexpr bool ratio_less_equal_v =3D + ratio_less_equal<_R1, _R2>::value; + template + inline constexpr bool ratio_greater_v =3D ratio_greater<_R1, _R2>::val= ue; + template + inline constexpr bool ratio_greater_equal_v + =3D ratio_greater_equal<_R1, _R2>::value; + + + + + template=3D 0), + bool =3D (_R2::num >=3D 0), + bool =3D ratio_less::value, _R1::den>, + ratio<__static_abs<_R2::num>::value, _R2::den> >::value> + struct __ratio_add_impl + { + private: + typedef typename __ratio_add_impl< + ratio<-_R1::num, _R1::den>, + ratio<-_R2::num, _R2::den> >::type __t; + public: + typedef ratio<-__t::num, __t::den> type; + }; + + + template + struct __ratio_add_impl<_R1, _R2, true, true, __b> + { + private: + static constexpr uintmax_t __g =3D __static_gcd<_R1::den, _R2::den>:= :value; + static constexpr uintmax_t __d2 =3D _R2::den / __g; + typedef __big_mul<_R1::den, __d2> __d; + typedef __big_mul<_R1::num, _R2::den / __g> __x; + typedef __big_mul<_R2::num, _R1::den / __g> __y; + typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n; + static_assert(__n::__hi >=3D __x::__hi, "Internal library error"); + typedef __big_div<__n::__hi, __n::__lo, __g> __ng; + static constexpr uintmax_t __g2 =3D __static_gcd<__ng::__rem, __g>::= value; + typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final; + static_assert(__n_final::__rem =3D=3D 0, "Internal library error"); + static_assert(__n_final::__quot_hi =3D=3D 0 && + __n_final::__quot_lo <=3D 0x7fffffffffffffffL, "overflow in additi= on"); + typedef __big_mul<_R1::den / __g2, __d2> __d_final; + static_assert(__d_final::__hi =3D=3D 0 && + __d_final::__lo <=3D 0x7fffffffffffffffL, "overflow in addition"); + public: + typedef ratio<__n_final::__quot_lo, __d_final::__lo> type; + }; + + template + struct __ratio_add_impl<_R1, _R2, false, true, true> + : __ratio_add_impl<_R2, _R1> + { }; + + + template + struct __ratio_add_impl<_R1, _R2, true, false, false> + { + private: + static constexpr uintmax_t __g =3D __static_gcd<_R1::den, _R2::den>:= :value; + static constexpr uintmax_t __d2 =3D _R2::den / __g; + typedef __big_mul<_R1::den, __d2> __d; + typedef __big_mul<_R1::num, _R2::den / __g> __x; + typedef __big_mul<-_R2::num, _R1::den / __g> __y; + typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n; + typedef __big_div<__n::__hi, __n::__lo, __g> __ng; + static constexpr uintmax_t __g2 =3D __static_gcd<__ng::__rem, __g>::= value; + typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final; + static_assert(__n_final::__rem =3D=3D 0, "Internal library error"); + static_assert(__n_final::__quot_hi =3D=3D 0 && + __n_final::__quot_lo <=3D 0x7fffffffffffffffL, "overflow in additi= on"); + typedef __big_mul<_R1::den / __g2, __d2> __d_final; + static_assert(__d_final::__hi =3D=3D 0 && + __d_final::__lo <=3D 0x7fffffffffffffffL, "overflow in addition"); + public: + typedef ratio<__n_final::__quot_lo, __d_final::__lo> type; + }; + + template + struct __ratio_add + { + typedef typename __ratio_add_impl<_R1, _R2>::type type; + static constexpr intmax_t num =3D type::num; + static constexpr intmax_t den =3D type::den; + }; +# 532 "/usr/include/c++/13/ratio" 3 + template + using ratio_add =3D typename __ratio_add<_R1, _R2>::type; + + + + template + struct __ratio_subtract + { + typedef typename __ratio_add< + _R1, + ratio<-_R2::num, _R2::den>>::type type; + + static constexpr intmax_t num =3D type::num; + static constexpr intmax_t den =3D type::den; + }; +# 559 "/usr/include/c++/13/ratio" 3 + template + using ratio_subtract =3D typename __ratio_subtract<_R1, _R2>::type; + + + typedef ratio<1, 1000000000000000000> atto; + typedef ratio<1, 1000000000000000> femto; + typedef ratio<1, 1000000000000> pico; + typedef ratio<1, 1000000000> nano; + typedef ratio<1, 1000000> micro; + typedef ratio<1, 1000> milli; + typedef ratio<1, 100> centi; + typedef ratio<1, 10> deci; + typedef ratio< 10, 1> deca; + typedef ratio< 100, 1> hecto; + typedef ratio< 1000, 1> kilo; + typedef ratio< 1000000, 1> mega; + typedef ratio< 1000000000, 1> giga; + typedef ratio< 1000000000000, 1> tera; + typedef ratio< 1000000000000000, 1> peta; + typedef ratio< 1000000000000000000, 1> exa; + + + +} +# 38 "/usr/include/c++/13/bits/chrono.h" 2 3 + + +# 1 "/usr/include/c++/13/ctime" 1 3 +# 39 "/usr/include/c++/13/ctime" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/ctime" 3 +# 41 "/usr/include/c++/13/bits/chrono.h" 2 3 +# 1 "/usr/include/c++/13/bits/parse_numbers.h" 1 3 +# 33 "/usr/include/c++/13/bits/parse_numbers.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/parse_numbers.h" 3 +# 42 "/usr/include/c++/13/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 =3D true_type; + }; + + template + struct _Digit<_Base, '1'> : integral_constant + { + using __valid =3D true_type; + }; + + template + struct _Digit_impl : integral_constant + { + static_assert(_Base > _Val, "invalid digit"); + using __valid =3D 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 =3D false_type; + }; + + + + template + using __ull_constant =3D integral_constant; + + template + struct _Power_help + { + using __next =3D typename _Power_help<_Base, _Digs...>::type; + using __valid_digit =3D typename _Digit<_Base, _Dig>::__valid; + using type + =3D __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>; + }; + + template + struct _Power_help<_Base, _Dig> + { + using __valid_digit =3D typename _Digit<_Base, _Dig>::__valid; + using type =3D __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 =3D _Digit<_Base, _Dig>; + using __valid_digit =3D typename __digit::__valid; + using __next =3D _Number_help<_Base, + __valid_digit::value ? _Pow / _Base : _Pow, + _Digs...>; + using type =3D __ull_constant<_Pow * __digit::value + __next::type::= value>; + static_assert((type::value / _Pow) =3D=3D __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 =3D __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 <=3D __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 =3D typename _Select_int_base< + __parse_int::_Parse_int<_Digs...>::value, + unsigned char, + unsigned short, + unsigned int, + unsigned long, + unsigned long long + >::type; + +} + + +} +# 42 "/usr/include/c++/13/bits/chrono.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + namespace filesystem { struct __file_clock; }; + + + namespace chrono + { + + + + + template> + class duration; + + + template + class time_point; + + } +# 77 "/usr/include/c++/13/bits/chrono.h" 3 + template + struct __duration_common_type + { }; + + template + struct __duration_common_type<_CT, _Period1, _Period2, + __void_t> + { + private: + using __gcd_num =3D __static_gcd<_Period1::num, _Period2::num>; + using __gcd_den =3D __static_gcd<_Period1::den, _Period2::den>; + using __cr =3D typename _CT::type; + using __r =3D ratio<__gcd_num::value, + (_Period1::den / __gcd_den::value) * _Period2::den>; + + public: + using type =3D chrono::duration<__cr, typename __r::type>; + }; + + + + + + + + template + struct common_type, + chrono::duration<_Rep2, _Period2>> + : __duration_common_type, + typename _Period1::type, + typename _Period2::type> + { }; + + + template + struct common_type, + chrono::duration<_Rep, _Period>> + { + using type =3D chrono::duration::type, + typename _Period::type>; + }; + + + template + struct common_type> + { + using type =3D chrono::duration::type, + typename _Period::type>; + }; + + + + + + + template + struct __timepoint_common_type + { }; + + template + struct __timepoint_common_type<_CT, _Clock, __void_t> + { + using type =3D chrono::time_point<_Clock, typename _CT::type>; + }; + + + + + + + + template + struct common_type, + chrono::time_point<_Clock, _Duration2>> + : __timepoint_common_type, _Clock> + { }; + + + template + struct common_type, + chrono::time_point<_Clock, _Duration>> + { using type =3D chrono::time_point<_Clock, _Duration>; }; + + + template + struct common_type> + { using type =3D chrono::time_point<_Clock, _Duration>; }; + + + + + namespace chrono + { + + + + + + + template + struct __duration_cast_impl + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) + * static_cast<_CR>(_CF::num) + / static_cast<_CR>(_CF::den))); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(__d.count())); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); + } + }; + + template + struct __is_duration + : std::false_type + { }; + + template + struct __is_duration> + : std::true_type + { }; + + template + using __enable_if_is_duration + =3D typename enable_if<__is_duration<_Tp>::value, _Tp>::type; + + template + using __disable_if_is_duration + =3D typename enable_if::value, _Tp>::type; + + + template + inline constexpr bool __is_duration_v =3D false; + template + inline constexpr bool __is_duration_v> =3D t= rue; + template + inline constexpr bool __is_time_point_v =3D false; + template + inline constexpr bool __is_time_point_v> = =3D true; +# 270 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[__nodiscard__]] + constexpr __enable_if_is_duration<_ToDur> + duration_cast(const duration<_Rep, _Period>& __d) + { + + if constexpr (is_same_v<_ToDur, duration<_Rep, _Period>>) + return __d; + else + + { + using __to_period =3D typename _ToDur::period; + using __to_rep =3D typename _ToDur::rep; + using __cf =3D ratio_divide<_Period, __to_period>; + using __cr =3D typename common_type<__to_rep, _Rep, intmax_t>::type; + using __dc =3D __duration_cast_impl<_ToDur, __cf, __cr, + __cf::num =3D=3D 1, __cf::den =3D=3D 1>; + return __dc::__cast(__d); + } + } +# 302 "/usr/include/c++/13/bits/chrono.h" 3 + template + struct treat_as_floating_point + : is_floating_point<_Rep> + { }; + + + template + inline constexpr bool treat_as_floating_point_v =3D + treat_as_floating_point<_Rep>::value; + + template<> + inline constexpr bool treat_as_floating_point_v =3D false; + template<> + inline constexpr bool treat_as_floating_point_v =3D false; + template<> + inline constexpr bool treat_as_floating_point_v =3D false; + template<> + inline constexpr bool treat_as_floating_point_v =3D true; + template<> + inline constexpr bool treat_as_floating_point_v =3D true; + template<> + inline constexpr bool treat_as_floating_point_v =3D tru= e; +# 384 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr __enable_if_is_duration<_ToDur> + floor(const duration<_Rep, _Period>& __d) + { + auto __to =3D chrono::duration_cast<_ToDur>(__d); + if (__to > __d) + return __to - _ToDur{1}; + return __to; + } +# 404 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr __enable_if_is_duration<_ToDur> + ceil(const duration<_Rep, _Period>& __d) + { + auto __to =3D chrono::duration_cast<_ToDur>(__d); + if (__to < __d) + return __to + _ToDur{1}; + return __to; + } +# 425 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr + enable_if_t< + __and_<__is_duration<_ToDur>, + __not_>>::value, + _ToDur> + round(const duration<_Rep, _Period>& __d) + { + _ToDur __t0 =3D chrono::floor<_ToDur>(__d); + _ToDur __t1 =3D __t0 + _ToDur{1}; + auto __diff0 =3D __d - __t0; + auto __diff1 =3D __t1 - __d; + if (__diff0 =3D=3D __diff1) + { + if (__t0.count() & 1) + return __t1; + return __t0; + } + else if (__diff0 < __diff1) + return __t0; + return __t1; + } + + + + + + + + template + [[nodiscard]] constexpr + enable_if_t::is_signed, duration<_Rep, _Period>> + abs(duration<_Rep, _Period> __d) + { + if (__d >=3D __d.zero()) + return __d; + return -__d; + } + + + namespace __detail { using chrono::ceil; } +# 492 "/usr/include/c++/13/bits/chrono.h" 3 + template + struct duration_values + { + static constexpr _Rep + zero() noexcept + { return _Rep(0); } + + static constexpr _Rep + max() noexcept + { return numeric_limits<_Rep>::max(); } + + static constexpr _Rep + min() noexcept + { return numeric_limits<_Rep>::lowest(); } + }; + + + + template + struct __is_ratio + : std::false_type + { }; + + template + struct __is_ratio> + : std::true_type + { }; + + + + template + class duration + { + static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); + static_assert(__is_ratio<_Period>::value, + "period must be a specialization of ratio"); + static_assert(_Period::num > 0, "period must be positive"); + + template + using __is_float =3D treat_as_floating_point<_Rep2>; + + static constexpr intmax_t + _S_gcd(intmax_t __m, intmax_t __n) noexcept + { + + + + do + { + intmax_t __rem =3D __m % __n; + __m =3D __n; + __n =3D __rem; + } + while (__n !=3D 0); + return __m; + + + + + + } + + + + + + template + using __divide =3D ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2), + (_R1::den / __gcd2) * (_R2::num / __gcd1)>; + + + template + using __is_harmonic + =3D __bool_constant<__divide<_Period2, _Period>::den =3D=3D 1>; + + public: + + using rep =3D _Rep; + using period =3D typename _Period::type; + + + constexpr duration() =3D default; + + duration(const duration&) =3D default; + + + + template, + __or_<__is_float, __not_<__is_float<_Rep2>>>>> + constexpr explicit duration(const _Rep2& __rep) + : __r(static_cast(__rep)) { } + + template, + __or_<__is_float, + __and_<__is_harmonic<_Period2>, + __not_<__is_float<_Rep2>>>>>> + constexpr duration(const duration<_Rep2, _Period2>& __d) + : __r(duration_cast(__d).count()) { } + + ~duration() =3D default; + duration& operator=3D(const duration&) =3D default; + + + constexpr rep + count() const + { return __r; } + + + + constexpr duration::type, period> + operator+() const + { return duration::type, period>(__r); } + + constexpr duration::type, period> + operator-() const + { return duration::type, period>(-__r); } + + constexpr duration& + operator++() + { + ++__r; + return *this; + } + + constexpr duration + operator++(int) + { return duration(__r++); } + + constexpr duration& + operator--() + { + --__r; + return *this; + } + + constexpr duration + operator--(int) + { return duration(__r--); } + + constexpr duration& + operator+=3D(const duration& __d) + { + __r +=3D __d.count(); + return *this; + } + + constexpr duration& + operator-=3D(const duration& __d) + { + __r -=3D __d.count(); + return *this; + } + + constexpr duration& + operator*=3D(const rep& __rhs) + { + __r *=3D __rhs; + return *this; + } + + constexpr duration& + operator/=3D(const rep& __rhs) + { + __r /=3D __rhs; + return *this; + } + + + template + constexpr + __enable_if_t::value, duration&> + operator%=3D(const rep& __rhs) + { + __r %=3D __rhs; + return *this; + } + + template + constexpr + __enable_if_t::value, duration&> + operator%=3D(const duration& __d) + { + __r %=3D __d.count(); + return *this; + } + + + static constexpr duration + zero() noexcept + { return duration(duration_values::zero()); } + + static constexpr duration + min() noexcept + { return duration(duration_values::min()); } + + static constexpr duration + max() noexcept + { return duration(duration_values::max()); } + + private: + rep __r; + }; + + + + + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator+(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() + __cd(__rhs).count()); + } + + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator-(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() - __cd(__rhs).count()); + } +# 738 "/usr/include/c++/13/bits/chrono.h" 3 + template::type> + using __common_rep_t =3D typename + enable_if::value, _CRep>::type; +# 750 "/usr/include/c++/13/bits/chrono.h" 3 + template + constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> + operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() * __s); + } + + template + constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> + operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) + { return __d * __s; } + + template + constexpr + duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Pe= riod> + operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() / __s); + } + + template + constexpr typename common_type<_Rep1, _Rep2>::type + operator/(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__lhs).count() / __cd(__rhs).count(); + } + + + template + constexpr + duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Pe= riod> + operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() % __s); + } + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator%(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() % __cd(__rhs).count()); + } +# 818 "/usr/include/c++/13/bits/chrono.h" 3 + template + constexpr bool + operator=3D=3D(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() =3D=3D __ct(__rhs).count(); + } + + template + constexpr bool + operator<(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() < __ct(__rhs).count(); + } +# 855 "/usr/include/c++/13/bits/chrono.h" 3 + template + constexpr bool + operator!=3D(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs =3D=3D __rhs); } + + + template + constexpr bool + operator<=3D(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__rhs < __lhs); } + + template + constexpr bool + operator>(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return __rhs < __lhs; } + + template + constexpr bool + operator>=3D(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs < __rhs); } +# 899 "/usr/include/c++/13/bits/chrono.h" 3 + using nanoseconds =3D duration; + + + using microseconds =3D duration; + + + using milliseconds =3D duration; + + + using seconds =3D duration; + + + using minutes =3D duration>; + + + using hours =3D duration>; +# 932 "/usr/include/c++/13/bits/chrono.h" 3 + template + class time_point + { + static_assert(__is_duration<_Dur>::value, + "duration must be a specialization of std::chrono::duration"); + + public: + typedef _Clock clock; + typedef _Dur duration; + typedef typename duration::rep rep; + typedef typename duration::period period; + + constexpr time_point() : __d(duration::zero()) + { } + + constexpr explicit time_point(const duration& __dur) + : __d(__dur) + { } + + + template>> + constexpr time_point(const time_point& __t) + : __d(__t.time_since_epoch()) + { } + + + constexpr duration + time_since_epoch() const + { return __d; } +# 988 "/usr/include/c++/13/bits/chrono.h" 3 + constexpr time_point& + operator+=3D(const duration& __dur) + { + __d +=3D __dur; + return *this; + } + + constexpr time_point& + operator-=3D(const duration& __dur) + { + __d -=3D __dur; + return *this; + } + + + static constexpr time_point + min() noexcept + { return time_point(duration::min()); } + + static constexpr time_point + max() noexcept + { return time_point(duration::max()); } + + private: + duration __d; + }; +# 1027 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[__nodiscard__]] constexpr + __enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDu= r>> + time_point_cast(const time_point<_Clock, _Dur>& __t) + { + typedef time_point<_Clock, _ToDur> __time_point; + return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); + } +# 1049 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr + enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>> + floor(const time_point<_Clock, _Dur>& __tp) + { + return time_point<_Clock, _ToDur>{ + chrono::floor<_ToDur>(__tp.time_since_epoch())}; + } +# 1070 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr + enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>> + ceil(const time_point<_Clock, _Dur>& __tp) + { + return time_point<_Clock, _ToDur>{ + chrono::ceil<_ToDur>(__tp.time_since_epoch())}; + } +# 1092 "/usr/include/c++/13/bits/chrono.h" 3 + template + [[nodiscard]] constexpr + enable_if_t<__is_duration_v<_ToDur> + && !treat_as_floating_point_v, + time_point<_Clock, _ToDur>> + round(const time_point<_Clock, _Dur>& __tp) + { + return time_point<_Clock, _ToDur>{ + chrono::round<_ToDur>(__tp.time_since_epoch())}; + } + + + + + + + template + constexpr time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator+(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<_Dur1,__dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__lhs.time_since_epoch() + __rhs); + } + + + template + constexpr time_point<_Clock, + typename common_type, _Dur2>::type> + operator+(const duration<_Rep1, _Period1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef typename common_type<__dur1,_Dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__rhs.time_since_epoch() + __lhs); + } + + + template + constexpr time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator-(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<_Dur1,__dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__lhs.time_since_epoch() -__rhs); + } + + + template + constexpr typename common_type<_Dur1, _Dur2>::type + operator-(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } + + + + + + + + template + constexpr bool + operator=3D=3D(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() =3D=3D __rhs.time_since_epoch(); } +# 1176 "/usr/include/c++/13/bits/chrono.h" 3 + template + constexpr bool + operator!=3D(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs =3D=3D __rhs); } + + + template + constexpr bool + operator<(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } + + template + constexpr bool + operator<=3D(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__rhs < __lhs); } + + template + constexpr bool + operator>(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __rhs < __lhs; } + + template + constexpr bool + operator>=3D(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs < __rhs); } +# 1228 "/usr/include/c++/13/bits/chrono.h" 3 +inline namespace _V2 { + + + + + + + + struct system_clock + { + typedef chrono::nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point time_point; + + static_assert(system_clock::duration::min() + < system_clock::duration::zero(), + "a clock's minimum duration cannot be less than its epoch"); + + static constexpr bool is_steady =3D false; + + static time_point + now() noexcept; + + + static std::time_t + to_time_t(const time_point& __t) noexcept + { + return std::time_t(duration_cast + (__t.time_since_epoch()).count()); + } + + static time_point + from_time_t(std::time_t __t) noexcept + { + typedef chrono::time_point __from; + return time_point_cast + (__from(chrono::seconds(__t))); + } + }; +# 1276 "/usr/include/c++/13/bits/chrono.h" 3 + struct steady_clock + { + typedef chrono::nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point time_point; + + static constexpr bool is_steady =3D true; + + static time_point + now() noexcept; + }; +# 1298 "/usr/include/c++/13/bits/chrono.h" 3 + using high_resolution_clock =3D system_clock; + +} +# 1324 "/usr/include/c++/13/bits/chrono.h" 3 + } + + + + + inline namespace literals + { +# 1355 "/usr/include/c++/13/bits/chrono.h" 3 + inline namespace chrono_literals + { + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wliteral-suffix" + + template + constexpr _Dur __check_overflow() + { + using _Val =3D __parse_int::_Parse_int<_Digits...>; + constexpr typename _Dur::rep __repval =3D _Val::value; + static_assert(__repval >=3D 0 && __repval =3D=3D _Val::value, + "literal value cannot be represented by duration type"); + return _Dur(__repval); + } + + + + constexpr chrono::duration> + operator""h(long double __hours) + { return chrono::duration>{__hours}; } + + + template + constexpr chrono::hours + operator""h() + { return __check_overflow(); } + + + constexpr chrono::duration> + operator""min(long double __mins) + { return chrono::duration>{__mins}; } + + + template + constexpr chrono::minutes + operator""min() + { return __check_overflow(); } + + + constexpr chrono::duration + operator""s(long double __secs) + { return chrono::duration{__secs}; } + + + template + constexpr chrono::seconds + operator""s() + { return __check_overflow(); } + + + constexpr chrono::duration + operator""ms(long double __msecs) + { return chrono::duration{__msecs}; } + + + template + constexpr chrono::milliseconds + operator""ms() + { return __check_overflow(); } + + + constexpr chrono::duration + operator""us(long double __usecs) + { return chrono::duration{__usecs}; } + + + template + constexpr chrono::microseconds + operator""us() + { return __check_overflow(); } + + + constexpr chrono::duration + operator""ns(long double __nsecs) + { return chrono::duration{__nsecs}; } + + + template + constexpr chrono::nanoseconds + operator""ns() + { return __check_overflow(); } + +#pragma GCC diagnostic pop + + } + } + + namespace chrono + { + using namespace literals::chrono_literals; + } + + + + namespace filesystem + { + struct __file_clock + { + using duration =3D chrono::nanoseconds; + using rep =3D duration::rep; + using period =3D duration::period; + using time_point =3D chrono::time_point<__file_clock>; + static constexpr bool is_steady =3D false; + + static time_point + now() noexcept + { return _S_from_sys(chrono::system_clock::now()); } +# 1481 "/usr/include/c++/13/bits/chrono.h" 3 + private: + using __sys_clock =3D chrono::system_clock; + + + + + static constexpr chrono::seconds _S_epoch_diff{6437664000}; + + protected: + + template + static + chrono::time_point<__file_clock, _Dur> + _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept + { + using __file_time =3D chrono::time_point<__file_clock, _Dur>; + return __file_time{__t.time_since_epoch()} - _S_epoch_diff; + } + + + template + static + chrono::time_point<__sys_clock, _Dur> + _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept + { + using __sys_time =3D chrono::time_point<__sys_clock, _Dur>; + return __sys_time{__t.time_since_epoch()} + _S_epoch_diff; + } + }; + } + + + +} +# 41 "/usr/include/c++/13/condition_variable" 2 3 + +# 1 "/usr/include/c++/13/bits/std_mutex.h" 1 3 +# 33 "/usr/include/c++/13/bits/std_mutex.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/std_mutex.h" 3 +# 43 "/usr/include/c++/13/bits/std_mutex.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/13/bits/std_mutex.h" 3 + class __mutex_base + { + protected: + typedef __gthread_mutex_t __native_type; + + + __native_type _M_mutex =3D { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, = { 0, 0 } } }; + + constexpr __mutex_base() noexcept =3D default; +# 80 "/usr/include/c++/13/bits/std_mutex.h" 3 + __mutex_base(const __mutex_base&) =3D delete; + __mutex_base& operator=3D(const __mutex_base&) =3D delete; + }; +# 96 "/usr/include/c++/13/bits/std_mutex.h" 3 + class mutex : private __mutex_base + { + public: + typedef __native_type* native_handle_type; + + + constexpr + + mutex() noexcept =3D default; + ~mutex() =3D default; + + mutex(const mutex&) =3D delete; + mutex& operator=3D(const mutex&) =3D delete; + + void + lock() + { + int __e =3D __gthread_mutex_lock(&_M_mutex); + + + if (__e) + __throw_system_error(__e); + } + + [[__nodiscard__]] + bool + try_lock() noexcept + { + + return !__gthread_mutex_trylock(&_M_mutex); + } + + void + unlock() + { + + __gthread_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() noexcept + { return &_M_mutex; } + }; + + + + + class __condvar + { + using timespec =3D __gthread_time_t; + + public: + __condvar() noexcept + { + + + + } + + ~__condvar() + { + int __e __attribute__((__unused__)) =3D __gthread_cond_destroy(&_M_c= ond); + do { if (std::__is_constant_evaluated() && !bool(__e !=3D 16)) __bui= ltin_unreachable(); } while (false); + } + + __condvar(const __condvar&) =3D delete; + __condvar& operator=3D(const __condvar&) =3D delete; + + __gthread_cond_t* native_handle() noexcept { return &_M_cond; } + + + void + wait(mutex& __m) + { + int __e __attribute__((__unused__)) + =3D __gthread_cond_wait(&_M_cond, __m.native_handle()); + do { if (std::__is_constant_evaluated() && !bool(__e =3D=3D 0)) __bu= iltin_unreachable(); } while (false); + } + + void + wait_until(mutex& __m, timespec& __abs_time) + { + __gthread_cond_timedwait(&_M_cond, __m.native_handle(), &__abs_time); + } + + + void + wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time) + { + pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock, + &__abs_time); + } + + + void + notify_one() noexcept + { + int __e __attribute__((__unused__)) =3D __gthread_cond_signal(&_M_co= nd); + do { if (std::__is_constant_evaluated() && !bool(__e =3D=3D 0)) __bu= iltin_unreachable(); } while (false); + } + + void + notify_all() noexcept + { + int __e __attribute__((__unused__)) =3D __gthread_cond_broadcast(&_M= _cond); + do { if (std::__is_constant_evaluated() && !bool(__e =3D=3D 0)) __bu= iltin_unreachable(); } while (false); + } + + protected: + + __gthread_cond_t _M_cond =3D { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0= } } }; + + + + }; + + + + + + struct defer_lock_t { explicit defer_lock_t() =3D default; }; + + + struct try_to_lock_t { explicit try_to_lock_t() =3D default; }; + + + + struct adopt_lock_t { explicit adopt_lock_t() =3D default; }; + + + inline constexpr defer_lock_t defer_lock { }; + + + inline constexpr try_to_lock_t try_to_lock { }; + + + inline constexpr adopt_lock_t adopt_lock { }; +# 242 "/usr/include/c++/13/bits/std_mutex.h" 3 + template + class lock_guard + { + public: + typedef _Mutex mutex_type; + + explicit lock_guard(mutex_type& __m) : _M_device(__m) + { _M_device.lock(); } + + lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m) + { } + + ~lock_guard() + { _M_device.unlock(); } + + lock_guard(const lock_guard&) =3D delete; + lock_guard& operator=3D(const lock_guard&) =3D delete; + + private: + mutex_type& _M_device; + }; + + + +} +# 43 "/usr/include/c++/13/condition_variable" 2 3 +# 1 "/usr/include/c++/13/bits/unique_lock.h" 1 3 +# 33 "/usr/include/c++/13/bits/unique_lock.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/unique_lock.h" 3 +# 43 "/usr/include/c++/13/bits/unique_lock.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 58 "/usr/include/c++/13/bits/unique_lock.h" 3 + template + class unique_lock + { + public: + typedef _Mutex mutex_type; + + unique_lock() noexcept + : _M_device(0), _M_owns(false) + { } + + explicit unique_lock(mutex_type& __m) + : _M_device(std::__addressof(__m)), _M_owns(false) + { + lock(); + _M_owns =3D true; + } + + unique_lock(mutex_type& __m, defer_lock_t) noexcept + : _M_device(std::__addressof(__m)), _M_owns(false) + { } + + unique_lock(mutex_type& __m, try_to_lock_t) + : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock()) + { } + + unique_lock(mutex_type& __m, adopt_lock_t) noexcept + : _M_device(std::__addressof(__m)), _M_owns(true) + { + + } + + template + unique_lock(mutex_type& __m, + const chrono::time_point<_Clock, _Duration>& __atime) + : _M_device(std::__addressof(__m)), + _M_owns(_M_device->try_lock_until(__atime)) + { } + + template + unique_lock(mutex_type& __m, + const chrono::duration<_Rep, _Period>& __rtime) + : _M_device(std::__addressof(__m)), + _M_owns(_M_device->try_lock_for(__rtime)) + { } + + ~unique_lock() + { + if (_M_owns) + unlock(); + } + + unique_lock(const unique_lock&) =3D delete; + unique_lock& operator=3D(const unique_lock&) =3D delete; + + unique_lock(unique_lock&& __u) noexcept + : _M_device(__u._M_device), _M_owns(__u._M_owns) + { + __u._M_device =3D 0; + __u._M_owns =3D false; + } + + unique_lock& operator=3D(unique_lock&& __u) noexcept + { + if(_M_owns) + unlock(); + + unique_lock(std::move(__u)).swap(*this); + + __u._M_device =3D 0; + __u._M_owns =3D false; + + return *this; + } + + void + lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_device->lock(); + _M_owns =3D true; + } + } + + [[__nodiscard__]] + bool + try_lock() + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns =3D _M_device->try_lock(); + return _M_owns; + } + } + + template + [[__nodiscard__]] + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns =3D _M_device->try_lock_until(__atime); + return _M_owns; + } + } + + template + [[__nodiscard__]] + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { + if (!_M_device) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_owns) + __throw_system_error(int(errc::resource_deadlock_would_occur)); + else + { + _M_owns =3D _M_device->try_lock_for(__rtime); + return _M_owns; + } + } + + void + unlock() + { + if (!_M_owns) + __throw_system_error(int(errc::operation_not_permitted)); + else if (_M_device) + { + _M_device->unlock(); + _M_owns =3D false; + } + } + + void + swap(unique_lock& __u) noexcept + { + std::swap(_M_device, __u._M_device); + std::swap(_M_owns, __u._M_owns); + } + + mutex_type* + release() noexcept + { + mutex_type* __ret =3D _M_device; + _M_device =3D 0; + _M_owns =3D false; + return __ret; + } + + [[__nodiscard__]] + bool + owns_lock() const noexcept + { return _M_owns; } + + explicit operator bool() const noexcept + { return owns_lock(); } + + [[__nodiscard__]] + mutex_type* + mutex() const noexcept + { return _M_device; } + + private: + mutex_type* _M_device; + bool _M_owns; + }; + + + + template + inline void + swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept + { __x.swap(__y); } + + +} +# 44 "/usr/include/c++/13/condition_variable" 2 3 +# 54 "/usr/include/c++/13/condition_variable" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 67 "/usr/include/c++/13/condition_variable" 3 + enum class cv_status { no_timeout, timeout }; + + + class condition_variable + { + using steady_clock =3D chrono::steady_clock; + using system_clock =3D chrono::system_clock; + + using __clock_t =3D steady_clock; + + + + + __condvar _M_cond; + + public: + typedef __gthread_cond_t* native_handle_type; + + condition_variable() noexcept; + ~condition_variable() noexcept; + + condition_variable(const condition_variable&) =3D delete; + condition_variable& operator=3D(const condition_variable&) =3D delete; + + void + notify_one() noexcept; + + void + notify_all() noexcept; + + void + wait(unique_lock& __lock); + + template + void + wait(unique_lock& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + + template + cv_status + wait_until(unique_lock& __lock, + const chrono::time_point& __atime) + { return __wait_until_impl(__lock, __atime); } + + + template + cv_status + wait_until(unique_lock& __lock, + const chrono::time_point& __atime) + { return __wait_until_impl(__lock, __atime); } + + template + cv_status + wait_until(unique_lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + + + + using __s_dur =3D typename __clock_t::duration; + const typename _Clock::time_point __c_entry =3D _Clock::now(); + const __clock_t::time_point __s_entry =3D __clock_t::now(); + const auto __delta =3D __atime - __c_entry; + const auto __s_atime =3D __s_entry + + chrono::__detail::ceil<__s_dur>(__delta); + + if (__wait_until_impl(__lock, __s_atime) =3D=3D cv_status::no_timeout) + return cv_status::no_timeout; + + + + if (_Clock::now() < __atime) + return cv_status::no_timeout; + return cv_status::timeout; + } + + template + bool + wait_until(unique_lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) =3D=3D cv_status::timeout) + return __p(); + return true; + } + + template + cv_status + wait_for(unique_lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime) + { + using __dur =3D typename steady_clock::duration; + return wait_until(__lock, + steady_clock::now() + + chrono::__detail::ceil<__dur>(__rtime)); + } + + template + bool + wait_for(unique_lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime, + _Predicate __p) + { + using __dur =3D typename steady_clock::duration; + return wait_until(__lock, + steady_clock::now() + + chrono::__detail::ceil<__dur>(__rtime), + std::move(__p)); + } + + native_handle_type + native_handle() + { return _M_cond.native_handle(); } + + private: + + template + cv_status + __wait_until_impl(unique_lock& __lock, + const chrono::time_point& __atime) + { + auto __s =3D chrono::time_point_cast(__atime); + auto __ns =3D chrono::duration_cast(__atime - __s); + + __gthread_time_t __ts =3D + { + static_cast(__s.time_since_epoch().count()), + static_cast(__ns.count()) + }; + + _M_cond.wait_until(*__lock.mutex(), 1, __ts); + + return (steady_clock::now() < __atime + ? cv_status::no_timeout : cv_status::timeout); + } + + + template + cv_status + __wait_until_impl(unique_lock& __lock, + const chrono::time_point& __atime) + { + auto __s =3D chrono::time_point_cast(__atime); + auto __ns =3D chrono::duration_cast(__atime - __s); + + __gthread_time_t __ts =3D + { + static_cast(__s.time_since_epoch().count()), + static_cast(__ns.count()) + }; + + _M_cond.wait_until(*__lock.mutex(), __ts); + + return (system_clock::now() < __atime + ? cv_status::no_timeout : cv_status::timeout); + } + }; + + void + notify_all_at_thread_exit(condition_variable&, unique_lock); + + struct __at_thread_exit_elt + { + __at_thread_exit_elt* _M_next; + void (*_M_cb)(void*); + }; + +inline namespace _V2 { + + + + class condition_variable_any + { + + using __clock_t =3D chrono::steady_clock; + + + + condition_variable _M_cond; + shared_ptr _M_mutex; + + + template + struct _Unlock + { + explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + ~_Unlock() noexcept(false) + { + if (uncaught_exception()) + { + if (true) + { _M_lock.lock(); } + if (false) + { ; } + if (false) + { } + } + else + _M_lock.lock(); + } +#pragma GCC diagnostic pop + + _Unlock(const _Unlock&) =3D delete; + _Unlock& operator=3D(const _Unlock&) =3D delete; + + _Lock& _M_lock; + }; + + public: + condition_variable_any() : _M_mutex(std::make_shared()) { } + ~condition_variable_any() =3D default; + + condition_variable_any(const condition_variable_any&) =3D delete; + condition_variable_any& operator=3D(const condition_variable_any&) =3D= delete; + + void + notify_one() noexcept + { + lock_guard __lock(*_M_mutex); + _M_cond.notify_one(); + } + + void + notify_all() noexcept + { + lock_guard __lock(*_M_mutex); + _M_cond.notify_all(); + } + + template + void + wait(_Lock& __lock) + { + shared_ptr __mutex =3D _M_mutex; + unique_lock __my_lock(*__mutex); + _Unlock<_Lock> __unlock(__lock); + + + unique_lock __my_lock2(std::move(__my_lock)); + _M_cond.wait(__my_lock2); + } + + + template + void + wait(_Lock& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + template + cv_status + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + shared_ptr __mutex =3D _M_mutex; + unique_lock __my_lock(*__mutex); + _Unlock<_Lock> __unlock(__lock); + + + unique_lock __my_lock2(std::move(__my_lock)); + return _M_cond.wait_until(__my_lock2, __atime); + } + + template + bool + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) =3D=3D cv_status::timeout) + return __p(); + return true; + } + + template + cv_status + wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rti= me) + { return wait_until(__lock, __clock_t::now() + __rtime); } + + template + bool + wait_for(_Lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) + { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__= p)); } +# 443 "/usr/include/c++/13/condition_variable" 3 + }; + +} + + + +} +# 732 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 1 "/usr/include/c++/13/mutex" 1 3 4 +# 32 "/usr/include/c++/13/mutex" 3 4 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/mutex" 3 +# 57 "/usr/include/c++/13/mutex" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 70 "/usr/include/c++/13/mutex" 3 + class __recursive_mutex_base + { + protected: + typedef __gthread_recursive_mutex_t __native_type; + + __recursive_mutex_base(const __recursive_mutex_base&) =3D delete; + __recursive_mutex_base& operator=3D(const __recursive_mutex_base&) =3D= delete; + + + __native_type _M_mutex =3D { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP,= 0, { 0, 0 } } }; + + __recursive_mutex_base() =3D default; +# 94 "/usr/include/c++/13/mutex" 3 + }; +# 106 "/usr/include/c++/13/mutex" 3 + class recursive_mutex : private __recursive_mutex_base + { + public: + typedef __native_type* native_handle_type; + + recursive_mutex() =3D default; + ~recursive_mutex() =3D default; + + recursive_mutex(const recursive_mutex&) =3D delete; + recursive_mutex& operator=3D(const recursive_mutex&) =3D delete; + + void + lock() + { + int __e =3D __gthread_recursive_mutex_lock(&_M_mutex); + + + if (__e) + __throw_system_error(__e); + } + + [[__nodiscard__]] + bool + try_lock() noexcept + { + + return !__gthread_recursive_mutex_trylock(&_M_mutex); + } + + void + unlock() + { + + __gthread_recursive_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() noexcept + { return &_M_mutex; } + }; + + + + + template + class __timed_mutex_impl + { + protected: + template + bool + _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { + + using __clock =3D chrono::steady_clock; + + + + + auto __rt =3D chrono::duration_cast<__clock::duration>(__rtime); + if (ratio_greater<__clock::period, _Period>()) + ++__rt; + return _M_try_lock_until(__clock::now() + __rt); + } + + template + bool + _M_try_lock_until(const chrono::time_point& __atime) + { + auto __s =3D chrono::time_point_cast(__atime); + auto __ns =3D chrono::duration_cast(__atime - __s); + + __gthread_time_t __ts =3D { + static_cast(__s.time_since_epoch().count()), + static_cast(__ns.count()) + }; + + return static_cast<_Derived*>(this)->_M_timedlock(__ts); + } + + + template + bool + _M_try_lock_until(const chrono::time_point& __atime) + { + auto __s =3D chrono::time_point_cast(__atime); + auto __ns =3D chrono::duration_cast(__atime - __s); + + __gthread_time_t __ts =3D { + static_cast(__s.time_since_epoch().count()), + static_cast(__ns.count()) + }; + + return static_cast<_Derived*>(this)->_M_clocklock(1, + __ts); + } + + + template + bool + _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { + + + + + + + auto __now =3D _Clock::now(); + do { + auto __rtime =3D __atime - __now; + if (_M_try_lock_for(__rtime)) + return true; + __now =3D _Clock::now(); + } while (__atime > __now); + return false; + } + }; +# 235 "/usr/include/c++/13/mutex" 3 + class timed_mutex + : private __mutex_base, public __timed_mutex_impl + { + public: + typedef __native_type* native_handle_type; + + timed_mutex() =3D default; + ~timed_mutex() =3D default; + + timed_mutex(const timed_mutex&) =3D delete; + timed_mutex& operator=3D(const timed_mutex&) =3D delete; + + void + lock() + { + int __e =3D __gthread_mutex_lock(&_M_mutex); + + + if (__e) + __throw_system_error(__e); + } + + [[__nodiscard__]] + bool + try_lock() noexcept + { + + return !__gthread_mutex_trylock(&_M_mutex); + } + + template + [[__nodiscard__]] + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { return _M_try_lock_for(__rtime); } + + template + [[__nodiscard__]] + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { return _M_try_lock_until(__atime); } + + void + unlock() + { + + __gthread_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() noexcept + { return &_M_mutex; } + + private: + friend class __timed_mutex_impl; + + bool + _M_timedlock(const __gthread_time_t& __ts) + { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); } + + + bool + _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts) + { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); } + + }; +# 312 "/usr/include/c++/13/mutex" 3 + class recursive_timed_mutex + : private __recursive_mutex_base, + public __timed_mutex_impl + { + public: + typedef __native_type* native_handle_type; + + recursive_timed_mutex() =3D default; + ~recursive_timed_mutex() =3D default; + + recursive_timed_mutex(const recursive_timed_mutex&) =3D delete; + recursive_timed_mutex& operator=3D(const recursive_timed_mutex&) =3D d= elete; + + void + lock() + { + int __e =3D __gthread_recursive_mutex_lock(&_M_mutex); + + + if (__e) + __throw_system_error(__e); + } + + [[__nodiscard__]] + bool + try_lock() noexcept + { + + return !__gthread_recursive_mutex_trylock(&_M_mutex); + } + + template + [[__nodiscard__]] + bool + try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) + { return _M_try_lock_for(__rtime); } + + template + [[__nodiscard__]] + bool + try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) + { return _M_try_lock_until(__atime); } + + void + unlock() + { + + __gthread_recursive_mutex_unlock(&_M_mutex); + } + + native_handle_type + native_handle() noexcept + { return &_M_mutex; } + + private: + friend class __timed_mutex_impl; + + bool + _M_timedlock(const __gthread_time_t& __ts) + { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); } + + + bool + _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts) + { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); } + + }; +# 559 "/usr/include/c++/13/mutex" 3 + namespace __detail + { + + template + inline int + __try_lock_impl(_Lockable& __l) + { + if (unique_lock<_Lockable> __lock{__l, try_to_lock}) + { + __lock.release(); + return -1; + } + else + return 0; + } + + + + template + inline int + __try_lock_impl(_L0& __l0, _Lockables&... __lockables) + { + + if constexpr ((is_same_v<_L0, _Lockables> && ...)) + { + constexpr int _Np =3D 1 + sizeof...(_Lockables); + unique_lock<_L0> __locks[_Np] =3D { + {__l0, defer_lock}, {__lockables, defer_lock}... + }; + for (int __i =3D 0; __i < _Np; ++__i) + { + if (!__locks[__i].try_lock()) + { + const int __failed =3D __i; + while (__i--) + __locks[__i].unlock(); + return __failed; + } + } + for (auto& __l : __locks) + __l.release(); + return -1; + } + else + + if (unique_lock<_L0> __lock{__l0, try_to_lock}) + { + int __idx =3D __detail::__try_lock_impl(__lockables...); + if (__idx =3D=3D -1) + { + __lock.release(); + return -1; + } + return __idx + 1; + } + else + return 0; + } + + } +# 631 "/usr/include/c++/13/mutex" 3 + template + [[__nodiscard__]] + inline int + try_lock(_L1& __l1, _L2& __l2, _L3&... __l3) + { + return __detail::__try_lock_impl(__l1, __l2, __l3...); + } + + + namespace __detail + { + + + + + + template + void + __lock_impl(int& __i, int __depth, _L0& __l0, _L1&... __l1) + { + while (__i >=3D __depth) + { + if (__i =3D=3D __depth) + { + int __failed =3D 1; + { + unique_lock<_L0> __first(__l0); + __failed +=3D __detail::__try_lock_impl(__l1...); + if (!__failed) + { + __i =3D -1; + __first.release(); + return; + } + } + + __gthread_yield(); + + constexpr auto __n =3D 1 + sizeof...(_L1); + __i =3D (__depth + __failed) % __n; + } + else + __detail::__lock_impl(__i, __depth + 1, __l1..., __l0); + } + } + + } +# 691 "/usr/include/c++/13/mutex" 3 + template + void + lock(_L1& __l1, _L2& __l2, _L3&... __l3) + { + + if constexpr (is_same_v<_L1, _L2> && (is_same_v<_L1, _L3> && ...)) + { + constexpr int _Np =3D 2 + sizeof...(_L3); + unique_lock<_L1> __locks[] =3D { + {__l1, defer_lock}, {__l2, defer_lock}, {__l3, defer_lock}... + }; + int __first =3D 0; + do { + __locks[__first].lock(); + for (int __j =3D 1; __j < _Np; ++__j) + { + const int __idx =3D (__first + __j) % _Np; + if (!__locks[__idx].try_lock()) + { + for (int __k =3D __j; __k !=3D 0; --__k) + __locks[(__first + __k - 1) % _Np].unlock(); + __first =3D __idx; + break; + } + } + } while (!__locks[__first].owns_lock()); + + for (auto& __l : __locks) + __l.release(); + } + else + + { + int __i =3D 0; + __detail::__lock_impl(__i, 0, __l1, __l2, __l3...); + } + } +# 739 "/usr/include/c++/13/mutex" 3 + template + class scoped_lock + { + public: + explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m.= ..)) + { std::lock(__m...); } + + explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept + : _M_devices(std::tie(__m...)) + { } + + ~scoped_lock() + { std::apply([](auto&... __m) { (__m.unlock(), ...); }, _M_devices);= } + + scoped_lock(const scoped_lock&) =3D delete; + scoped_lock& operator=3D(const scoped_lock&) =3D delete; + + private: + tuple<_MutexTypes&...> _M_devices; + }; + + template<> + class scoped_lock<> + { + public: + explicit scoped_lock() =3D default; + explicit scoped_lock(adopt_lock_t) noexcept { } + ~scoped_lock() =3D default; + + scoped_lock(const scoped_lock&) =3D delete; + scoped_lock& operator=3D(const scoped_lock&) =3D delete; + }; + + template + class scoped_lock<_Mutex> + { + public: + using mutex_type =3D _Mutex; + + explicit scoped_lock(mutex_type& __m) : _M_device(__m) + { _M_device.lock(); } + + explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept + : _M_device(__m) + { } + + ~scoped_lock() + { _M_device.unlock(); } + + scoped_lock(const scoped_lock&) =3D delete; + scoped_lock& operator=3D(const scoped_lock&) =3D delete; + + private: + mutex_type& _M_device; + }; + + + + + struct once_flag + { + constexpr once_flag() noexcept =3D default; + + + once_flag(const once_flag&) =3D delete; + + once_flag& operator=3D(const once_flag&) =3D delete; + + private: + + + __gthread_once_t _M_once =3D 0; + + struct _Prepare_execution; + + template + friend void + call_once(once_flag& __once, _Callable&& __f, _Args&&... __args); + }; + + + + + + extern __thread void* __once_callable; + extern __thread void (*__once_call)(); + + + struct once_flag::_Prepare_execution + { + template + explicit + _Prepare_execution(_Callable& __c) + { + + __once_callable =3D std::__addressof(__c); + + __once_call =3D [] { (*static_cast<_Callable*>(__once_callable))(); }; + } + + ~_Prepare_execution() + { + + __once_callable =3D nullptr; + __once_call =3D nullptr; + } + + _Prepare_execution(const _Prepare_execution&) =3D delete; + _Prepare_execution& operator=3D(const _Prepare_execution&) =3D delete; + }; +# 891 "/usr/include/c++/13/mutex" 3 + extern "C" void __once_proxy(void); + + + template + void + call_once(once_flag& __once, _Callable&& __f, _Args&&... __args) + { + + auto __callable =3D [&] { + std::__invoke(std::forward<_Callable>(__f), + std::forward<_Args>(__args)...); + }; + + once_flag::_Prepare_execution __exec(__callable); + + + if (int __e =3D __gthread_once(&__once._M_once, &__once_proxy)) + __throw_system_error(__e); + } +# 1012 "/usr/include/c++/13/mutex" 3 + +} +# 733 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +# 837 "/usr/include/gtest/internal/gtest-port.h" 3 4 +namespace testing { + +class Message; + + + +using std::get; +using std::make_tuple; +using std::tuple; +using std::tuple_element; +using std::tuple_size; + +namespace internal { + + + + +class Secret; + + + +__attribute__((visibility("default"))) bool IsTrue(bool condition); +# 891 "/usr/include/gtest/internal/gtest-port.h" 3 4 +class __attribute__((visibility("default"))) RE { + public: + + + RE(const RE& other) { Init(other.pattern()); } + + + RE(const ::std::string& regex) { Init(regex.c_str()); } + + RE(const char* regex) { Init(regex); } + ~RE(); + + + const char* pattern() const { return pattern_; } + + + + + + static bool FullMatch(const ::std::string& str, const RE& re) { + return FullMatch(str.c_str(), re); + } + static bool PartialMatch(const ::std::string& str, const RE& re) { + return PartialMatch(str.c_str(), re); + } + + static bool FullMatch(const char* str, const RE& re); + static bool PartialMatch(const char* str, const RE& re); + + private: + void Init(const char* regex); + const char* pattern_; + bool is_valid_; + + + + regex_t full_regex_; + regex_t partial_regex_; + + + + + + +}; + + + + + +__attribute__((visibility("default"))) ::std::string FormatFileLocation(co= nst char* file, int line); + + + + +__attribute__((visibility("default"))) ::std::string FormatCompilerIndepen= dentFileLocation(const char* file, + int line); + + + + + + + +enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATA= L }; + + + + +class __attribute__((visibility("default"))) GTestLog { + public: + GTestLog(GTestLogSeverity severity, const char* file, int line); + + + ~GTestLog(); + + ::std::ostream& GetStream() { return ::std::cerr; } + + private: + const GTestLogSeverity severity_; + + GTestLog(const GTestLog&) =3D delete; + GTestLog& operator=3D(const GTestLog&) =3D delete; +}; +# 983 "/usr/include/gtest/internal/gtest-port.h" 3 4 +inline void LogToStderr() {} +inline void FlushInfoLog() { fflush(nullptr); } +# 1031 "/usr/include/gtest/internal/gtest-port.h" 3 4 +template +struct ConstRef { + typedef const T& type; +}; +template +struct ConstRef { + typedef T& type; +}; +# 1064 "/usr/include/gtest/internal/gtest-port.h" 3 4 +template +inline To ImplicitCast_(To x) { + return x; +} +# 1090 "/usr/include/gtest/internal/gtest-port.h" 3 4 +template +inline To DownCast_(From* f) { + + + + +=20 + if (false) { +=20=20=20 + const To to =3D nullptr; + ::testing::internal::ImplicitCast_(to); + } + + + + switch (0) case 0: default: if (::testing::internal::IsTrue(f =3D=3D nul= lptr || dynamic_cast(f) !=3D nullptr)) ; else ::testing::internal::GTes= tLog(::testing::internal::GTEST_FATAL, "/usr/include/gtest/internal/gtest-p= ort.h", 1105) .GetStream() << "Condition " "f =3D=3D nullptr || dynamic_cas= t(f) !=3D nullptr" " failed. "; + + return static_cast(f); +} + + + + + + +template +Derived* CheckedDowncastToActualType(Base* base) { + + switch (0) case 0: default: if (::testing::internal::IsTrue(typeid(*base= ) =3D=3D typeid(Derived))) ; else ::testing::internal::GTestLog(::testing::= internal::GTEST_FATAL, "/usr/include/gtest/internal/gtest-port.h", 1118) .G= etStream() << "Condition " "typeid(*base) =3D=3D typeid(Derived)" " failed.= "; + + + + + + return dynamic_cast(base); + + + +} +# 1138 "/usr/include/gtest/internal/gtest-port.h" 3 4 +__attribute__((visibility("default"))) void CaptureStdout(); +__attribute__((visibility("default"))) std::string GetCapturedStdout(); +__attribute__((visibility("default"))) void CaptureStderr(); +__attribute__((visibility("default"))) std::string GetCapturedStderr(); + + + +__attribute__((visibility("default"))) size_t GetFileSize(FILE* file); + + +__attribute__((visibility("default"))) std::string ReadEntireFile(FILE* fi= le); + + +__attribute__((visibility("default"))) std::vector GetArgvs(); + + + +std::vector GetInjectableArgvs(); + +void SetInjectableArgvs(const std::vector* new_argvs); +void SetInjectableArgvs(const std::vector& new_argvs); +void ClearInjectableArgvs(); +# 1203 "/usr/include/gtest/internal/gtest-port.h" 3 4 + +# 1213 "/usr/include/gtest/internal/gtest-port.h" 3 4 +class __attribute__((visibility("default"))) Notification { + public: + Notification() : notified_(false) {} + Notification(const Notification&) =3D delete; + Notification& operator=3D(const Notification&) =3D delete; + + + + void Notify() { + std::lock_guard lock(mu_); + notified_ =3D true; + cv_.notify_all(); + } + + + + void WaitForNotification() { + std::unique_lock lock(mu_); + cv_.wait(lock, [this]() { return notified_; }); + } + + private: + std::mutex mu_; + std::condition_variable cv_; + bool notified_; +}; + +# 1252 "/usr/include/gtest/internal/gtest-port.h" 3 4 +class ThreadWithParamBase { + public: + virtual ~ThreadWithParamBase() {} + virtual void Run() =3D 0; +}; + + + + + + + +extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { + static_cast(thread)->Run(); + return nullptr; +} +# 1281 "/usr/include/gtest/internal/gtest-port.h" 3 4 +template +class ThreadWithParam : public ThreadWithParamBase { + public: + typedef void UserThreadFunc(T); + + ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_= start) + : func_(func), + param_(param), + thread_can_start_(thread_can_start), + finished_(false) { + ThreadWithParamBase* const base =3D this; + + + if (const int gtest_error =3D (pthread_create(&thread_, nullptr, &Thre= adFuncWithCLinkage, base))) ::testing::internal::GTestLog(::testing::intern= al::GTEST_FATAL, "/usr/include/gtest/internal/gtest-port.h", 1294) .GetStre= am() << "pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base)" = << "failed with error " << gtest_error + ; + } + ~ThreadWithParam() override { Join(); } + + void Join() { + if (!finished_) { + if (const int gtest_error =3D (pthread_join(thread_, nullptr))) ::te= sting::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/include/g= test/internal/gtest-port.h", 1301) .GetStream() << "pthread_join(thread_, n= ullptr)" << "failed with error " << gtest_error; + finished_ =3D true; + } + } + + void Run() override { + if (thread_can_start_ !=3D nullptr) thread_can_start_->WaitForNotifica= tion(); + func_(param_); + } + + private: + UserThreadFunc* const func_; + const T param_; + + + Notification* const thread_can_start_; + bool finished_; + + pthread_t thread_; + + ThreadWithParam(const ThreadWithParam&) =3D delete; + ThreadWithParam& operator=3D(const ThreadWithParam&) =3D delete; +}; +# 1616 "/usr/include/gtest/internal/gtest-port.h" 3 4 +class MutexBase { + public: + + void Lock() { + if (const int gtest_error =3D (pthread_mutex_lock(&mutex_))) ::testing= ::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/include/gtest/= internal/gtest-port.h", 1620) .GetStream() << "pthread_mutex_lock(&mutex_)"= << "failed with error " << gtest_error; + owner_ =3D pthread_self(); + has_owner_ =3D true; + } + + + void Unlock() { + + + + + has_owner_ =3D false; + if (const int gtest_error =3D (pthread_mutex_unlock(&mutex_))) ::testi= ng::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/include/gtes= t/internal/gtest-port.h", 1632) .GetStream() << "pthread_mutex_unlock(&mute= x_)" << "failed with error " << gtest_error; + } + + + + void AssertHeld() const { + switch (0) case 0: default: if (::testing::internal::IsTrue(has_owner_= && pthread_equal(owner_, pthread_self()))) ; else ::testing::internal::GTe= stLog(::testing::internal::GTEST_FATAL, "/usr/include/gtest/internal/gtest-= port.h", 1638) .GetStream() << "Condition " "has_owner_ && pthread_equal(ow= ner_, pthread_self())" " failed. " + << "The current thread is not holding the mutex @" << this; + } + + + + + + + public: + pthread_mutex_t mutex_; + + + + + + + bool has_owner_; + pthread_t owner_; +}; +# 1674 "/usr/include/gtest/internal/gtest-port.h" 3 4 +class Mutex : public MutexBase { + public: + Mutex() { + if (const int gtest_error =3D (pthread_mutex_init(&mutex_, nullptr))) = ::testing::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/inclu= de/gtest/internal/gtest-port.h", 1677) .GetStream() << "pthread_mutex_init(= &mutex_, nullptr)" << "failed with error " << gtest_error; + has_owner_ =3D false; + } + ~Mutex() { if (const int gtest_error =3D (pthread_mutex_destroy(&mutex_)= )) ::testing::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/in= clude/gtest/internal/gtest-port.h", 1680) .GetStream() << "pthread_mutex_de= stroy(&mutex_)" << "failed with error " << gtest_error; } + + private: + Mutex(const Mutex&) =3D delete; + Mutex& operator=3D(const Mutex&) =3D delete; +}; + + + + + + +class GTestMutexLock { + public: + explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock= (); } + + ~GTestMutexLock() { mutex_->Unlock(); } + + private: + MutexBase* const mutex_; + + GTestMutexLock(const GTestMutexLock&) =3D delete; + GTestMutexLock& operator=3D(const GTestMutexLock&) =3D delete; +}; + +typedef GTestMutexLock MutexLock; + + + + + + + +class ThreadLocalValueHolderBase { + public: + virtual ~ThreadLocalValueHolderBase() {} +}; + + + +extern "C" inline void DeleteThreadLocalValue(void* value_holder) { + delete static_cast(value_holder); +} + + +template +class __attribute__((visibility("default"))) ThreadLocal { + public: + ThreadLocal() + : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory(= )) {} + explicit ThreadLocal(const T& value) + : key_(CreateKey()), + default_factory_(new InstanceValueHolderFactory(value)) {} + + ~ThreadLocal() { + + DeleteThreadLocalValue(pthread_getspecific(key_)); + + + + if (const int gtest_error =3D (pthread_key_delete(key_))) ::testing::i= nternal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/include/gtest/int= ernal/gtest-port.h", 1740) .GetStream() << "pthread_key_delete(key_)" << "f= ailed with error " << gtest_error; + } + + T* pointer() { return GetOrCreateValue(); } + const T* pointer() const { return GetOrCreateValue(); } + const T& get() const { return *pointer(); } + void set(const T& value) { *pointer() =3D value; } + + private: + + class ValueHolder : public ThreadLocalValueHolderBase { + public: + ValueHolder() : value_() {} + explicit ValueHolder(const T& value) : value_(value) {} + + T* pointer() { return &value_; } + + private: + T value_; + ValueHolder(const ValueHolder&) =3D delete; + ValueHolder& operator=3D(const ValueHolder&) =3D delete; + }; + + static pthread_key_t CreateKey() { + pthread_key_t key; + + + if (const int gtest_error =3D (pthread_key_create(&key, &DeleteThreadL= ocalValue))) ::testing::internal::GTestLog(::testing::internal::GTEST_FATAL= , "/usr/include/gtest/internal/gtest-port.h", 1767) .GetStream() << "pthrea= d_key_create(&key, &DeleteThreadLocalValue)" << "failed with error " << gte= st_error + ; + return key; + } + + T* GetOrCreateValue() const { + ThreadLocalValueHolderBase* const holder =3D + static_cast(pthread_getspecific(key_)= ); + if (holder !=3D nullptr) { + return CheckedDowncastToActualType(holder)->pointer(); + } + + ValueHolder* const new_holder =3D default_factory_->MakeNewHolder(); + ThreadLocalValueHolderBase* const holder_base =3D new_holder; + if (const int gtest_error =3D (pthread_setspecific(key_, holder_base))= ) ::testing::internal::GTestLog(::testing::internal::GTEST_FATAL, "/usr/inc= lude/gtest/internal/gtest-port.h", 1781) .GetStream() << "pthread_setspecif= ic(key_, holder_base)" << "failed with error " << gtest_error; + return new_holder->pointer(); + } + + class ValueHolderFactory { + public: + ValueHolderFactory() {} + virtual ~ValueHolderFactory() {} + virtual ValueHolder* MakeNewHolder() const =3D 0; + + private: + ValueHolderFactory(const ValueHolderFactory&) =3D delete; + ValueHolderFactory& operator=3D(const ValueHolderFactory&) =3D delete; + }; + + class DefaultValueHolderFactory : public ValueHolderFactory { + public: + DefaultValueHolderFactory() {} + ValueHolder* MakeNewHolder() const override { return new ValueHolder()= ; } + + private: + DefaultValueHolderFactory(const DefaultValueHolderFactory&) =3D delete; + DefaultValueHolderFactory& operator=3D(const DefaultValueHolderFactory= &) =3D + delete; + }; + + class InstanceValueHolderFactory : public ValueHolderFactory { + public: + explicit InstanceValueHolderFactory(const T& value) : value_(value) {} + ValueHolder* MakeNewHolder() const override { + return new ValueHolder(value_); + } + + private: + const T value_; + + InstanceValueHolderFactory(const InstanceValueHolderFactory&) =3D dele= te; + InstanceValueHolderFactory& operator=3D(const InstanceValueHolderFacto= ry&) =3D + delete; + }; + + + const pthread_key_t key_; + std::unique_ptr default_factory_; + + ThreadLocal(const ThreadLocal&) =3D delete; + ThreadLocal& operator=3D(const ThreadLocal&) =3D delete; +}; +# 1882 "/usr/include/gtest/internal/gtest-port.h" 3 4 +__attribute__((visibility("default"))) size_t GetThreadCount(); +# 1899 "/usr/include/gtest/internal/gtest-port.h" 3 4 +inline bool IsAlpha(char ch) { + return isalpha(static_cast(ch)) !=3D 0; +} +inline bool IsAlNum(char ch) { + return isalnum(static_cast(ch)) !=3D 0; +} +inline bool IsDigit(char ch) { + return isdigit(static_cast(ch)) !=3D 0; +} +inline bool IsLower(char ch) { + return islower(static_cast(ch)) !=3D 0; +} +inline bool IsSpace(char ch) { + return isspace(static_cast(ch)) !=3D 0; +} +inline bool IsUpper(char ch) { + return isupper(static_cast(ch)) !=3D 0; +} +inline bool IsXDigit(char ch) { + return isxdigit(static_cast(ch)) !=3D 0; +} + + + + + +inline bool IsXDigit(char16_t ch) { + const unsigned char low_byte =3D static_cast(ch); + return ch =3D=3D low_byte && isxdigit(low_byte) !=3D 0; +} +inline bool IsXDigit(char32_t ch) { + const unsigned char low_byte =3D static_cast(ch); + return ch =3D=3D low_byte && isxdigit(low_byte) !=3D 0; +} +inline bool IsXDigit(wchar_t ch) { + const unsigned char low_byte =3D static_cast(ch); + return ch =3D=3D low_byte && isxdigit(low_byte) !=3D 0; +} + +inline char ToLower(char ch) { + return static_cast(tolower(static_cast(ch))); +} +inline char ToUpper(char ch) { + return static_cast(toupper(static_cast(ch))); +} + +inline std::string StripTrailingSpaces(std::string str) { + std::string::iterator it =3D str.end(); + while (it !=3D str.begin() && IsSpace(*--it)) it =3D str.erase(it); + return str; +} + + + + + + + +namespace posix { +# 2013 "/usr/include/gtest/internal/gtest-port.h" 3 4 +typedef struct stat StatStruct; + +inline int FileNo(FILE* file) { return fileno(file); } +inline int DoIsATTY(int fd) { return isatty(fd); } +inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf= ); } +inline int StrCaseCmp(const char* s1, const char* s2) { + return strcasecmp(s1, s2); +} +inline char* StrDup(const char* src) { return strdup(src); } +inline int RmDir(const char* dir) { return rmdir(dir); } +inline bool IsDir(const StatStruct& st) { return ((((st.st_mode)) & 017000= 0) =3D=3D (0040000)); } + + + +inline int IsATTY(int fd) { + + + + int savedErrno =3D (*__errno_location ()); + int isAttyValue =3D DoIsATTY(fd); + (*__errno_location ()) =3D savedErrno; + + return isAttyValue; +} + + + + + + + + + + + +inline int ChDir(const char* dir) { return chdir(dir); } + +inline FILE* FOpen(const char* path, const char* mode) { + + + + + + + + return fopen(path, mode); + +} + +inline FILE* FReopen(const char* path, const char* mode, FILE* stream) { + return freopen(path, mode, stream); +} +inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } + +inline int FClose(FILE* fp) { return fclose(fp); } + +inline int Read(int fd, void* buf, unsigned int count) { + return static_cast(read(fd, buf, count)); +} +inline int Write(int fd, const void* buf, unsigned int count) { + return static_cast(write(fd, buf, count)); +} +inline int Close(int fd) { return close(fd); } +inline const char* StrError(int errnum) { return strerror(errnum); } + +inline const char* GetEnv(const char* name) { +# 2090 "/usr/include/gtest/internal/gtest-port.h" 3 4 + return getenv(name); + +} + + + + + + + + + +[[noreturn]] inline void Abort() { abort(); } + + +} +# 2126 "/usr/include/gtest/internal/gtest-port.h" 3 4 +using BiggestInt =3D long long; + + +constexpr BiggestInt kMaxBiggestInt =3D (std::numeric_limits::= max)(); +# 2149 "/usr/include/gtest/internal/gtest-port.h" 3 4 +template +class TypeWithSize { + public: + + + using UInt =3D void; +}; + + +template <> +class TypeWithSize<4> { + public: + using Int =3D std::int32_t; + using UInt =3D std::uint32_t; +}; + + +template <> +class TypeWithSize<8> { + public: + using Int =3D std::int64_t; + using UInt =3D std::uint64_t; +}; + + +using TimeInMillis =3D int64_t; +# 2263 "/usr/include/gtest/internal/gtest-port.h" 3 4 +__attribute__((visibility("default"))) bool ParseInt32(const Message& src_= text, const char* str, + int32_t* value); + + + +bool BoolFromGTestEnv(const char* flag, bool default_val); +__attribute__((visibility("default"))) int32_t Int32FromGTestEnv(const cha= r* flag, int32_t default_val); +std::string OutputFlagAlsoCheckEnvVar(); +const char* StringFromGTestEnv(const char* flag, const char* default_val); + +} +} +# 2312 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/c++/13/any" 1 3 4 +# 32 "/usr/include/c++/13/any" 3 4 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/any" 3 +# 42 "/usr/include/c++/13/any" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 55 "/usr/include/c++/13/any" 3 + class bad_any_cast : public bad_cast + { + public: + virtual const char* what() const noexcept { return "bad any_cast"; } + }; + + [[gnu::noreturn]] inline void __throw_bad_any_cast() + { + + + + __builtin_abort(); + + } +# 80 "/usr/include/c++/13/any" 3 + class any + { + + union _Storage + { + constexpr _Storage() : _M_ptr{nullptr} {} + + + _Storage(const _Storage&) =3D delete; + _Storage& operator=3D(const _Storage&) =3D delete; + + void* _M_ptr; + aligned_storage::type _M_buffer; + }; + + template, + bool _Fits =3D (sizeof(_Tp) <=3D sizeof(_Storage)) + && (alignof(_Tp) <=3D alignof(_Storage))> + using _Internal =3D std::integral_constant; + + template + struct _Manager_internal; + + template + struct _Manager_external; + + template + using _Manager =3D __conditional_t<_Internal<_Tp>::value, + _Manager_internal<_Tp>, + _Manager_external<_Tp>>; + + template> + using _Decay_if_not_any =3D enable_if_t, _VTp>; + + + template > + void __do_emplace(_Args&&... __args) + { + reset(); + _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...); + _M_manager =3D &_Mgr::_S_manage; + } + + + + template > + void __do_emplace(initializer_list<_Up> __il, _Args&&... __args) + { + reset(); + _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...); + _M_manager =3D &_Mgr::_S_manage; + } + + template + using __any_constructible + =3D enable_if<__and_, + is_constructible<_Tp, _Args...>>::value, + _Res>; + + template + using __any_constructible_t + =3D typename __any_constructible::type; + + template + using __emplace_t + =3D typename __any_constructible<_VTp&, _VTp, _Args...>::type; + + public: + + + + constexpr any() noexcept : _M_manager(nullptr) { } + + + any(const any& __other) + { + if (!__other.has_value()) + _M_manager =3D nullptr; + else + { + _Arg __arg; + __arg._M_any =3D this; + __other._M_manager(_Op_clone, &__other, &__arg); + } + } + + + + + + + any(any&& __other) noexcept + { + if (!__other.has_value()) + _M_manager =3D nullptr; + else + { + _Arg __arg; + __arg._M_any =3D this; + __other._M_manager(_Op_xfer, &__other, &__arg); + } + } + + + template , + typename _Mgr =3D _Manager<_VTp>, + enable_if_t + && !__is_in_place_type_v<_VTp>, bool> =3D true> + any(_Tp&& __value) + : _M_manager(&_Mgr::_S_manage) + { + _Mgr::_S_create(_M_storage, std::forward<_Tp>(__value)); + } + + + template , + typename _Mgr =3D _Manager<_VTp>, + __any_constructible_t<_VTp, _Args&&...> =3D false> + explicit + any(in_place_type_t<_Tp>, _Args&&... __args) + : _M_manager(&_Mgr::_S_manage) + { + _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...); + } + + + + template , typename _Mgr =3D _Manager<_VTp>, + __any_constructible_t<_VTp, initializer_list<_Up>&, + _Args&&...> =3D false> + explicit + any(in_place_type_t<_Tp>, initializer_list<_Up> __il, _Args&&... __a= rgs) + : _M_manager(&_Mgr::_S_manage) + { + _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...); + } + + + ~any() { reset(); } + + + + + any& + operator=3D(const any& __rhs) + { + *this =3D any(__rhs); + return *this; + } + + + + + + + any& + operator=3D(any&& __rhs) noexcept + { + if (!__rhs.has_value()) + reset(); + else if (this !=3D &__rhs) + { + reset(); + _Arg __arg; + __arg._M_any =3D this; + __rhs._M_manager(_Op_xfer, &__rhs, &__arg); + } + return *this; + } + + + template + enable_if_t>::value, an= y&> + operator=3D(_Tp&& __rhs) + { + *this =3D any(std::forward<_Tp>(__rhs)); + return *this; + } + + + template + __emplace_t, _Args...> + emplace(_Args&&... __args) + { + using _VTp =3D decay_t<_Tp>; + __do_emplace<_VTp>(std::forward<_Args>(__args)...); + return *any::_Manager<_VTp>::_S_access(_M_storage); + } + + + + template + __emplace_t, initializer_list<_Up>&, _Args&&...> + emplace(initializer_list<_Up> __il, _Args&&... __args) + { + using _VTp =3D decay_t<_Tp>; + __do_emplace<_VTp, _Up>(__il, std::forward<_Args>(__args)...); + return *any::_Manager<_VTp>::_S_access(_M_storage); + } + + + + + void reset() noexcept + { + if (has_value()) + { + _M_manager(_Op_destroy, this, nullptr); + _M_manager =3D nullptr; + } + } + + + void swap(any& __rhs) noexcept + { + if (!has_value() && !__rhs.has_value()) + return; + + if (has_value() && __rhs.has_value()) + { + if (this =3D=3D &__rhs) + return; + + any __tmp; + _Arg __arg; + __arg._M_any =3D &__tmp; + __rhs._M_manager(_Op_xfer, &__rhs, &__arg); + __arg._M_any =3D &__rhs; + _M_manager(_Op_xfer, this, &__arg); + __arg._M_any =3D this; + __tmp._M_manager(_Op_xfer, &__tmp, &__arg); + } + else + { + any* __empty =3D !has_value() ? this : &__rhs; + any* __full =3D !has_value() ? &__rhs : this; + _Arg __arg; + __arg._M_any =3D __empty; + __full->_M_manager(_Op_xfer, __full, &__arg); + } + } + + + + + bool has_value() const noexcept { return _M_manager !=3D nullptr; } + + + + const type_info& type() const noexcept + { + if (!has_value()) + return typeid(void); + _Arg __arg; + _M_manager(_Op_get_type_info, this, &__arg); + return *__arg._M_typeinfo; + } + + + + template + static constexpr bool __is_valid_cast() + { return __or_, is_copy_constructible<_Tp>>::value= ; } + + + private: + enum _Op { + _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer + }; + + union _Arg + { + void* _M_obj; + const std::type_info* _M_typeinfo; + any* _M_any; + }; + + void (*_M_manager)(_Op, const any*, _Arg*); + _Storage _M_storage; + + + template + friend void* __any_caster(const any* __any); + + + + template + struct _Manager_internal + { + static void + _S_manage(_Op __which, const any* __anyp, _Arg* __arg); + + template + static void + _S_create(_Storage& __storage, _Up&& __value) + { + void* __addr =3D &__storage._M_buffer; + ::new (__addr) _Tp(std::forward<_Up>(__value)); + } + + template + static void + _S_create(_Storage& __storage, _Args&&... __args) + { + void* __addr =3D &__storage._M_buffer; + ::new (__addr) _Tp(std::forward<_Args>(__args)...); + } + + static _Tp* + _S_access(const _Storage& __storage) + { + + const void* __addr =3D &__storage._M_buffer; + return static_cast<_Tp*>(const_cast(__addr)); + } + }; + + + template + struct _Manager_external + { + static void + _S_manage(_Op __which, const any* __anyp, _Arg* __arg); + + template + static void + _S_create(_Storage& __storage, _Up&& __value) + { + __storage._M_ptr =3D new _Tp(std::forward<_Up>(__value)); + } + template + static void + _S_create(_Storage& __storage, _Args&&... __args) + { + __storage._M_ptr =3D new _Tp(std::forward<_Args>(__args)...); + } + static _Tp* + _S_access(const _Storage& __storage) + { + + return static_cast<_Tp*>(__storage._M_ptr); + } + }; + }; + + + inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); } + + + template + inline + enable_if_t, _Args...>, a= ny> + make_any(_Args&&... __args) + { + return any(in_place_type<_Tp>, std::forward<_Args>(__args)...); + } + + + template + inline + enable_if_t, + initializer_list<_Up>&, _Args...>, any> + make_any(initializer_list<_Up> __il, _Args&&... __args) + { + return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...); + } +# 460 "/usr/include/c++/13/any" 3 + template + inline _ValueType any_cast(const any& __any) + { + using _Up =3D __remove_cvref_t<_ValueType>; + static_assert(any::__is_valid_cast<_ValueType>(), + "Template argument must be a reference or CopyConstructible type"); + static_assert(is_constructible_v<_ValueType, const _Up&>, + "Template argument must be constructible from a const value."); + auto __p =3D any_cast<_Up>(&__any); + if (__p) + return static_cast<_ValueType>(*__p); + __throw_bad_any_cast(); + } +# 486 "/usr/include/c++/13/any" 3 + template + inline _ValueType any_cast(any& __any) + { + using _Up =3D __remove_cvref_t<_ValueType>; + static_assert(any::__is_valid_cast<_ValueType>(), + "Template argument must be a reference or CopyConstructible type"); + static_assert(is_constructible_v<_ValueType, _Up&>, + "Template argument must be constructible from an lvalue."); + auto __p =3D any_cast<_Up>(&__any); + if (__p) + return static_cast<_ValueType>(*__p); + __throw_bad_any_cast(); + } + + template + inline _ValueType any_cast(any&& __any) + { + using _Up =3D __remove_cvref_t<_ValueType>; + static_assert(any::__is_valid_cast<_ValueType>(), + "Template argument must be a reference or CopyConstructible type"); + static_assert(is_constructible_v<_ValueType, _Up>, + "Template argument must be constructible from an rvalue."); + auto __p =3D any_cast<_Up>(&__any); + if (__p) + return static_cast<_ValueType>(std::move(*__p)); + __throw_bad_any_cast(); + } + + + + template + void* __any_caster(const any* __any) + { + + + using _Up =3D remove_cv_t<_Tp>; + + + if constexpr (!is_same_v, _Up>) + return nullptr; + + else if constexpr (!is_copy_constructible_v<_Up>) + return nullptr; + + else if (__any->_M_manager =3D=3D &any::_Manager<_Up>::_S_manage + + || __any->type() =3D=3D typeid(_Tp) + + ) + { + return any::_Manager<_Up>::_S_access(__any->_M_storage); + } + return nullptr; + } +# 553 "/usr/include/c++/13/any" 3 + template + inline const _ValueType* any_cast(const any* __any) noexcept + { + if constexpr (is_object_v<_ValueType>) + if (__any) + return static_cast<_ValueType*>(__any_caster<_ValueType>(__any)); + return nullptr; + } + + template + inline _ValueType* any_cast(any* __any) noexcept + { + if constexpr (is_object_v<_ValueType>) + if (__any) + return static_cast<_ValueType*>(__any_caster<_ValueType>(__any)); + return nullptr; + } + + + template + void + any::_Manager_internal<_Tp>:: + _S_manage(_Op __which, const any* __any, _Arg* __arg) + { + + auto __ptr =3D reinterpret_cast(&__any->_M_storage._M_bu= ffer); + switch (__which) + { + case _Op_access: + __arg->_M_obj =3D const_cast<_Tp*>(__ptr); + break; + case _Op_get_type_info: + + __arg->_M_typeinfo =3D &typeid(_Tp); + + break; + case _Op_clone: + ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr); + __arg->_M_any->_M_manager =3D __any->_M_manager; + break; + case _Op_destroy: + __ptr->~_Tp(); + break; + case _Op_xfer: + ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp + (std::move(*const_cast<_Tp*>(__ptr))); + __ptr->~_Tp(); + __arg->_M_any->_M_manager =3D __any->_M_manager; + const_cast(__any)->_M_manager =3D nullptr; + break; + } + } + + template + void + any::_Manager_external<_Tp>:: + _S_manage(_Op __which, const any* __any, _Arg* __arg) + { + + auto __ptr =3D static_cast(__any->_M_storage._M_ptr); + switch (__which) + { + case _Op_access: + __arg->_M_obj =3D const_cast<_Tp*>(__ptr); + break; + case _Op_get_type_info: + + __arg->_M_typeinfo =3D &typeid(_Tp); + + break; + case _Op_clone: + __arg->_M_any->_M_storage._M_ptr =3D new _Tp(*__ptr); + __arg->_M_any->_M_manager =3D __any->_M_manager; + break; + case _Op_destroy: + delete __ptr; + break; + case _Op_xfer: + __arg->_M_any->_M_storage._M_ptr =3D __any->_M_storage._M_ptr; + __arg->_M_any->_M_manager =3D __any->_M_manager; + const_cast(__any)->_M_manager =3D nullptr; + break; + } + } + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template<> + struct _Never_valueless_alt + : std::true_type + { }; + } + + +} +# 2313 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +namespace testing { +namespace internal { +using Any =3D ::std::any; +} +} +# 2342 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/c++/13/optional" 1 3 4 +# 33 "/usr/include/c++/13/optional" 3 4 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/optional" 3 + + + + + + + +# 1 "/usr/include/c++/13/bits/enable_special_members.h" 1 3 +# 33 "/usr/include/c++/13/bits/enable_special_members.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/enable_special_members.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + struct _Enable_default_constructor_tag + { + explicit constexpr _Enable_default_constructor_tag() =3D default; + }; + + + + + + +template + struct _Enable_default_constructor + { + constexpr _Enable_default_constructor() noexcept =3D default; + constexpr _Enable_default_constructor(_Enable_default_constructor cons= t&) + noexcept =3D default; + constexpr _Enable_default_constructor(_Enable_default_constructor&&) + noexcept =3D default; + _Enable_default_constructor& + operator=3D(_Enable_default_constructor const&) noexcept =3D default; + _Enable_default_constructor& + operator=3D(_Enable_default_constructor&&) noexcept =3D default; + + + constexpr explicit + _Enable_default_constructor(_Enable_default_constructor_tag) { } + }; + + + + + + + +template + struct _Enable_destructor { }; + + + + + + +template + struct _Enable_copy_move { }; +# 96 "/usr/include/c++/13/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 =3D delete; + constexpr _Enable_default_constructor(_Enable_default_constructor cons= t&) + noexcept =3D default; + constexpr _Enable_default_constructor(_Enable_default_constructor&&) + noexcept =3D default; + _Enable_default_constructor& + operator=3D(_Enable_default_constructor const&) noexcept =3D default; + _Enable_default_constructor& + operator=3D(_Enable_default_constructor&&) noexcept =3D default; + + + constexpr explicit + _Enable_default_constructor(_Enable_default_constructor_tag) { } + }; + +template + struct _Enable_destructor + { ~_Enable_destructor() noexcept =3D delete; }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D default; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D def= ault; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept =3D default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept =3D del= ete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move const&) noexcept =3D delete; + _Enable_copy_move& + operator=3D(_Enable_copy_move&&) noexcept =3D delete; + }; + + + +} +# 42 "/usr/include/c++/13/optional" 2 3 +# 54 "/usr/include/c++/13/optional" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/include/c++/13/optional" 3 + 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() =3D default; + virtual ~bad_optional_access() =3D default; + + const char* what() const noexcept override + { return "bad optional access"; } + }; + + + [[__noreturn__]] inline void + __throw_bad_optional_access() + { (__builtin_abort()); } + + + + template + struct _Optional_payload_base + { + using _Stored_type =3D remove_const_t<_Tp>; + + _Optional_payload_base() =3D default; + ~_Optional_payload_base() =3D 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 __engaged, + const _Optional_payload_base& __other) + { + if (__other._M_engaged) + this->_M_construct(__other._M_get()); + } + + + + constexpr + _Optional_payload_base(bool __engaged, + _Optional_payload_base&& __other) + { + if (__other._M_engaged) + this->_M_construct(std::move(__other._M_get())); + } + + + + _Optional_payload_base(const _Optional_payload_base&) =3D default; + + + + _Optional_payload_base(_Optional_payload_base&&) =3D default; + + _Optional_payload_base& + operator=3D(const _Optional_payload_base&) =3D default; + + _Optional_payload_base& + operator=3D(_Optional_payload_base&&) =3D default; + + + constexpr void + _M_copy_assign(const _Optional_payload_base& __other) + { + if (this->_M_engaged && __other._M_engaged) + this->_M_get() =3D __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() =3D 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)...) + { } +# 232 "/usr/include/c++/13/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)...) + { } +# 263 "/usr/include/c++/13/optional" 3 + ~_Storage() { } + + _Empty_byte _M_empty; + _Up _M_value; + }; + + _Storage<_Stored_type> _M_payload; + + bool _M_engaged =3D 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 =3D true; + } + + constexpr void + _M_destroy() noexcept + { + _M_engaged =3D false; + _M_payload._M_value.~_Stored_type(); + } +# 305 "/usr/include/c++/13/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(); + } + }; + + + template , + bool =3D + is_trivially_copy_assignable_v<_Tp> + && is_trivially_copy_constructible_v<_Tp>, + bool =3D + 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() =3D default; + }; + + + template + struct _Optional_payload<_Tp, true, false, true> + : _Optional_payload_base<_Tp> + { + using _Optional_payload_base<_Tp>::_Optional_payload_base; + + _Optional_payload() =3D default; + ~_Optional_payload() =3D default; + _Optional_payload(const _Optional_payload&) =3D default; + _Optional_payload(_Optional_payload&&) =3D default; + _Optional_payload& operator=3D(_Optional_payload&&) =3D default; + + + constexpr + _Optional_payload& + operator=3D(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() =3D default; + ~_Optional_payload() =3D default; + _Optional_payload(const _Optional_payload&) =3D default; + _Optional_payload(_Optional_payload&&) =3D default; + _Optional_payload& operator=3D(const _Optional_payload&) =3D default; + + + constexpr + _Optional_payload& + operator=3D(_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() =3D default; + ~_Optional_payload() =3D default; + _Optional_payload(const _Optional_payload&) =3D default; + _Optional_payload(_Optional_payload&&) =3D default; + + + constexpr + _Optional_payload& + operator=3D(const _Optional_payload& __other) + { + this->_M_copy_assign(__other); + return *this; + } + + + constexpr + _Optional_payload& + operator=3D(_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() =3D default; + _Optional_payload(const _Optional_payload&) =3D default; + _Optional_payload(_Optional_payload&&) =3D default; + _Optional_payload& operator=3D(const _Optional_payload&) =3D default; + _Optional_payload& operator=3D(_Optional_payload&&) =3D default; + + + ~_Optional_payload() { this->_M_reset(); } + }; + + + + template + class _Optional_base_impl + { + protected: + using _Stored_type =3D 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 + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) = __builtin_unreachable(); } while (false); + return static_cast<_Dp*>(this)->_M_payload._M_get(); + } + + constexpr const _Tp& + _M_get() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) = __builtin_unreachable(); } while (false); + return static_cast(this)->_M_payload._M_get(); + } + }; +# 507 "/usr/include/c++/13/optional" 3 + template, + bool =3D is_trivially_move_constructible_v<_Tp>> + struct _Optional_base + : _Optional_base_impl<_Tp, _Optional_base<_Tp>> + { + + constexpr _Optional_base() =3D default; + + + template, bool> =3D false> + constexpr explicit + _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(in_place, std::forward<_Args>(__args)...) + { } + + template&, + _Args...>, bool> =3D 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) + noexcept(is_nothrow_move_constructible_v<_Tp>) + : _M_payload(__other._M_payload._M_engaged, + std::move(__other._M_payload)) + { } + + + _Optional_base& operator=3D(const _Optional_base&) =3D default; + _Optional_base& operator=3D(_Optional_base&&) =3D default; + + _Optional_payload<_Tp> _M_payload; + }; + + template + struct _Optional_base<_Tp, false, true> + : _Optional_base_impl<_Tp, _Optional_base<_Tp>> + { + + constexpr _Optional_base() =3D default; + + + template, bool> =3D false> + constexpr explicit + _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(in_place, std::forward<_Args>(__args)...) + { } + + template&, + _Args...>, bool> =3D 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) =3D default; + + + _Optional_base& operator=3D(const _Optional_base&) =3D default; + _Optional_base& operator=3D(_Optional_base&&) =3D default; + + _Optional_payload<_Tp> _M_payload; + }; + + template + struct _Optional_base<_Tp, true, false> + : _Optional_base_impl<_Tp, _Optional_base<_Tp>> + { + + constexpr _Optional_base() =3D default; + + + template, bool> =3D false> + constexpr explicit + _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(in_place, std::forward<_Args>(__args)...) + { } + + template&, + _Args...>, bool> =3D 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) =3D 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=3D(const _Optional_base&) =3D default; + _Optional_base& operator=3D(_Optional_base&&) =3D default; + + _Optional_payload<_Tp> _M_payload; + }; + + template + struct _Optional_base<_Tp, true, true> + : _Optional_base_impl<_Tp, _Optional_base<_Tp>> + { + + constexpr _Optional_base() =3D default; + + + template, bool> =3D false> + constexpr explicit + _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(in_place, std::forward<_Args>(__args)...) + { } + + template&, + _Args...>, bool> =3D 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) =3D default; + constexpr _Optional_base(_Optional_base&& __other) =3D default; + + + _Optional_base& operator=3D(const _Optional_base&) =3D default; + _Optional_base& operator=3D(_Optional_base&&) =3D default; + + _Optional_payload<_Tp> _M_payload; + }; + + template + class optional; + + template + inline constexpr bool __is_optional_v =3D false; + template + inline constexpr bool __is_optional_v> =3D true; + + template + using __converts_from_optional =3D + __or_&>, + is_constructible<_Tp, optional<_Up>&>, + is_constructible<_Tp, const optional<_Up>&&>, + is_constructible<_Tp, optional<_Up>&&>, + is_convertible&, _Tp>, + is_convertible&, _Tp>, + is_convertible&&, _Tp>, + is_convertible&&, _Tp>>; + + template + using __assigns_from_optional =3D + __or_&>, + is_assignable<_Tp&, optional<_Up>&>, + is_assignable<_Tp&, const optional<_Up>&&>, + is_assignable<_Tp&, optional<_Up>&&>>; + + + + + 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 =3D _Optional_base<_Tp>; + + + template + using __not_self =3D __not_>>; + template + using __not_tag =3D __not_>>; + template + using _Requires =3D enable_if_t<__and_v<_Cond...>, bool>; + + public: + using value_type =3D _Tp; + + constexpr optional() noexcept { } + + constexpr optional(nullopt_t) noexcept { } + + + template, __not_tag<_Up>, + is_constructible<_Tp, _Up>, + is_convertible<_Up, _Tp>> =3D true> + constexpr + optional(_Up&& __t) + noexcept(is_nothrow_constructible_v<_Tp, _Up>) + : _Base(std::in_place, std::forward<_Up>(__t)) { } + + template, __not_tag<_Up>, + is_constructible<_Tp, _Up>, + __not_>> =3D 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, + __not_<__converts_from_optional<_Tp, _Up>>> =3D true> + constexpr + optional(const optional<_Up>& __t) + noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) + { + if (__t) + emplace(*__t); + } + + template>, + is_constructible<_Tp, const _Up&>, + __not_>, + __not_<__converts_from_optional<_Tp, _Up>>> =3D false> + explicit constexpr + optional(const optional<_Up>& __t) + noexcept(is_nothrow_constructible_v<_Tp, const _Up&>) + { + if (__t) + emplace(*__t); + } + + template>, + is_constructible<_Tp, _Up>, + is_convertible<_Up, _Tp>, + __not_<__converts_from_optional<_Tp, _Up>>> =3D true> + constexpr + optional(optional<_Up>&& __t) + noexcept(is_nothrow_constructible_v<_Tp, _Up>) + { + if (__t) + emplace(std::move(*__t)); + } + + template>, + is_constructible<_Tp, _Up>, + __not_>, + __not_<__converts_from_optional<_Tp, _Up>>> =3D false> + explicit constexpr + optional(optional<_Up>&& __t) + noexcept(is_nothrow_constructible_v<_Tp, _Up>) + { + if (__t) + emplace(std::move(*__t)); + } + + template> =3D 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...>> =3D 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=3D(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=3D(_Up&& __u) + noexcept(__and_v, + is_nothrow_assignable<_Tp&, _Up>>) + { + if (this->_M_is_engaged()) + this->_M_get() =3D std::forward<_Up>(__u); + else + this->_M_construct(std::forward<_Up>(__u)); + + return *this; + } + + template + + 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=3D(const optional<_Up>& __u) + noexcept(__and_v, + is_nothrow_assignable<_Tp&, const _Up&>>) + { + if (__u) + { + if (this->_M_is_engaged()) + this->_M_get() =3D *__u; + else + this->_M_construct(*__u); + } + else + { + this->_M_reset(); + } + return *this; + } + + template + + 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=3D(optional<_Up>&& __u) + noexcept(__and_v, + is_nothrow_assignable<_Tp&, _Up>>) + { + if (__u) + { + if (this->_M_is_engaged()) + this->_M_get() =3D std::move(*__u); + else + this->_M_construct(std::move(*__u)); + } + 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 + { return std::__addressof(this->_M_get()); } + + constexpr _Tp* + operator->() noexcept + { return std::__addressof(this->_M_get()); } + + constexpr const _Tp& + operator*() const& noexcept + { return this->_M_get(); } + + constexpr _Tp& + operator*()& noexcept + { return this->_M_get(); } + + constexpr _Tp&& + operator*()&& noexcept + { return std::move(this->_M_get()); } + + constexpr const _Tp&& + operator*() const&& noexcept + { 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)); + } +# 1170 "/usr/include/c++/13/optional" 3 + void reset() noexcept { this->_M_reset(); } + + private: +# 1183 "/usr/include/c++/13/optional" 3 + }; + + template + using __optional_relop_t =3D + enable_if_t::value, bool>; + + template + using __optional_eq_t =3D __optional_relop_t< + decltype(std::declval() =3D=3D std::declval(= )) + >; + + template + using __optional_ne_t =3D __optional_relop_t< + decltype(std::declval() !=3D std::declval()) + >; + + template + using __optional_lt_t =3D __optional_relop_t< + decltype(std::declval() < std::declval()) + >; + + template + using __optional_gt_t =3D __optional_relop_t< + decltype(std::declval() > std::declval()) + >; + + template + using __optional_le_t =3D __optional_relop_t< + decltype(std::declval() <=3D std::declval()) + >; + + template + using __optional_ge_t =3D __optional_relop_t< + decltype(std::declval() >=3D std::declval()) + >; + + + template + constexpr auto + operator=3D=3D(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) + -> __optional_eq_t<_Tp, _Up> + { + return static_cast(__lhs) =3D=3D static_cast(__rhs) + && (!__lhs || *__lhs =3D=3D *__rhs); + } + + template + constexpr auto + operator!=3D(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) + -> __optional_ne_t<_Tp, _Up> + { + return static_cast(__lhs) !=3D static_cast(__rhs) + || (static_cast(__lhs) && *__lhs !=3D *__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<=3D(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) + -> __optional_le_t<_Tp, _Up> + { + return !__lhs || (static_cast(__rhs) && *__lhs <=3D *__rhs); + } + + template + constexpr auto + operator>=3D(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) + -> __optional_ge_t<_Tp, _Up> + { + return !__rhs || (static_cast(__lhs) && *__lhs >=3D *__rhs); + } +# 1280 "/usr/include/c++/13/optional" 3 + template + constexpr bool + operator=3D=3D(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return !__lhs; } + + + + + + + + template + constexpr bool + operator=3D=3D(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return !__rhs; } + + template + constexpr bool + operator!=3D(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return static_cast(__lhs); } + + template + constexpr bool + operator!=3D(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<=3D(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return !__lhs; } + + template + constexpr bool + operator<=3D(nullopt_t, const optional<_Tp>& ) noexcept + { return true; } + + template + constexpr bool + operator>=3D(const optional<_Tp>& , nullopt_t) noexcept + { return true; } + + template + constexpr bool + operator>=3D(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return !__rhs; } + + + + template + constexpr auto + operator=3D=3D(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_eq_t<_Tp, _Up> + { return __lhs && *__lhs =3D=3D __rhs; } + + template + constexpr auto + operator=3D=3D(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_eq_t<_Up, _Tp> + { return __rhs && __lhs =3D=3D *__rhs; } + + template + constexpr auto + operator!=3D(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_ne_t<_Tp, _Up> + { return !__lhs || *__lhs !=3D __rhs; } + + template + constexpr auto + operator!=3D(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_ne_t<_Up, _Tp> + { return !__rhs || __lhs !=3D *__rhs; } + + template + constexpr auto + operator<(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_lt_t<_Tp, _Up> + { return !__lhs || *__lhs < __rhs; } + + template + constexpr auto + operator<(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_lt_t<_Up, _Tp> + { return __rhs && __lhs < *__rhs; } + + template + constexpr auto + operator>(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_gt_t<_Tp, _Up> + { return __lhs && *__lhs > __rhs; } + + template + constexpr auto + operator>(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_gt_t<_Up, _Tp> + { return !__rhs || __lhs > *__rhs; } + + template + constexpr auto + operator<=3D(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_le_t<_Tp, _Up> + { return !__lhs || *__lhs <=3D __rhs; } + + template + constexpr auto + operator<=3D(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_le_t<_Up, _Tp> + { return __rhs && __lhs <=3D *__rhs; } + + template + constexpr auto + operator>=3D(const optional<_Tp>& __lhs, const _Up& __rhs) + -> __optional_ge_t<_Tp, _Up> + { return __lhs && *__lhs >=3D __rhs; } + + template + constexpr auto + operator>=3D(const _Up& __lhs, const optional<_Tp>& __rhs) + -> __optional_ge_t<_Up, _Tp> + { return !__rhs || __lhs >=3D *__rhs; } +# 1433 "/usr/include/c++/13/optional" 3 + template +=20=20=20 + 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>&) =3D 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, + bool =3D __poison_hash<_Up>::__enable_hash_call> + struct __optional_hash_call_base + { + size_t + operator()(const optional<_Tp>& __t) const + noexcept(noexcept(hash<_Up>{}(*__t))) + { + + + constexpr size_t __magic_disengaged_hash =3D static_cast(-3333); + return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash; + } + }; + + template + struct __optional_hash_call_base<_Tp, _Up, false> {}; + + template + struct hash> + : private __poison_hash>, + public __optional_hash_call_base<_Tp> + { + using result_type [[__deprecated__]] =3D size_t; + using argument_type [[__deprecated__]] =3D optional<_Tp>; + }; + + template + struct __is_fast_hash>> : __is_fast_hash> + { }; + + + + + template optional(_Tp) -> optional<_Tp>; + + + +} +# 2343 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +namespace testing { +namespace internal { +template +using Optional =3D ::std::optional; +inline ::std::nullopt_t Nullopt() { return ::std::nullopt; } +} +} +# 2373 "/usr/include/gtest/internal/gtest-port.h" 3 4 +namespace testing { +namespace internal { +using StringView =3D ::std::string_view; +} +} +# 2401 "/usr/include/gtest/internal/gtest-port.h" 3 4 +# 1 "/usr/include/c++/13/variant" 1 3 4 +# 32 "/usr/include/c++/13/variant" 3 4 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/variant" 3 +# 58 "/usr/include/c++/13/variant" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template class tuple; + template class variant; + template struct hash; + + 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 =3D variant_size<_Variant>::val= ue; + + template + inline constexpr size_t + variant_size_v> =3D sizeof...(_Types); + + template + inline constexpr size_t + variant_size_v> =3D sizeof...(_Types); + + template + struct variant_alternative; + + template + struct variant_alternative<_Np, variant<_Types...>> + { + static_assert(_Np < sizeof...(_Types)); + + using type =3D typename _Nth_type<_Np, _Types...>::type; + }; + + template + using variant_alternative_t =3D + typename variant_alternative<_Np, _Variant>::type; + + template + struct variant_alternative<_Np, const _Variant> + { using type =3D const variant_alternative_t<_Np, _Variant>; }; + + template + struct variant_alternative<_Np, volatile _Variant> + { using type =3D volatile variant_alternative_t<_Np, _Variant>; }; + + template + struct variant_alternative<_Np, const volatile _Variant> + { using type =3D const volatile variant_alternative_t<_Np, _Variant>; = }; + + inline constexpr size_t variant_npos =3D -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 +=20=20=20 + 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 =3D __variant_idx_cookie; }; + + template struct __deduce_visit_result { using type =3D _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>(__visit= or), + 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<_Type, true> + { + 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> + { +# 278 "/usr/include/c++/13/variant" 3 + 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 =3D=3D 0) + return std::forward<_Union>(__u)._M_first._M_get(); + else if constexpr (_Np =3D=3D 1) + return std::forward<_Union>(__u)._M_rest._M_first._M_get(); + else if constexpr (_Np =3D=3D 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); + } + + + template + constexpr decltype(auto) + __get(_Variant&& __v) noexcept + { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); } + + template + struct _Traits + { + static constexpr bool _S_default_ctor =3D + is_default_constructible_v::type>; + static constexpr bool _S_copy_ctor =3D + (is_copy_constructible_v<_Types> && ...); + static constexpr bool _S_move_ctor =3D + (is_move_constructible_v<_Types> && ...); + static constexpr bool _S_copy_assign =3D + _S_copy_ctor + && (is_copy_assignable_v<_Types> && ...); + static constexpr bool _S_move_assign =3D + _S_move_ctor + && (is_move_assignable_v<_Types> && ...); + + static constexpr bool _S_trivial_dtor =3D + (is_trivially_destructible_v<_Types> && ...); + static constexpr bool _S_trivial_copy_ctor =3D + (is_trivially_copy_constructible_v<_Types> && ...); + static constexpr bool _S_trivial_move_ctor =3D + (is_trivially_move_constructible_v<_Types> && ...); + static constexpr bool _S_trivial_copy_assign =3D + _S_trivial_dtor && _S_trivial_copy_ctor + && (is_trivially_copy_assignable_v<_Types> && ...); + static constexpr bool _S_trivial_move_assign =3D + _S_trivial_dtor && _S_trivial_move_ctor + && (is_trivially_move_assignable_v<_Types> && ...); + + + + static constexpr bool _S_nothrow_default_ctor =3D + is_nothrow_default_constructible_v< + typename _Nth_type<0, _Types...>::type>; + static constexpr bool _S_nothrow_copy_ctor =3D false; + static constexpr bool _S_nothrow_move_ctor =3D + (is_nothrow_move_constructible_v<_Types> && ...); + static constexpr bool _S_nothrow_copy_assign =3D false; + static constexpr bool _S_nothrow_move_assign =3D + _S_nothrow_move_ctor + && (is_nothrow_move_assignable_v<_Types> && ...); + }; + + + template + union _Variadic_union + { + _Variadic_union() =3D default; + + template + _Variadic_union(in_place_index_t<_Np>, _Args&&...) =3D delete; + }; + + template + union _Variadic_union<_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)...) + { } +# 407 "/usr/include/c++/13/variant" 3 + _Uninitialized<_First> _M_first; + _Variadic_union<_Rest...> _M_rest; + }; + + + + + + + template + struct _Never_valueless_alt + : __and_, is_trivially_copyable<_T= p>> + { }; +# 431 "/usr/include/c++/13/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 =3D + 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 =3D static_cast<__index_type>(variant_npos); + } + +=20=20=20=20=20 + ~_Variant_storage() + { _M_reset(); } + + constexpr bool + _M_valid() const noexcept + { + if constexpr (__variant::__never_valueless<_Types...>()) + return true; + return this->_M_index !=3D __index_type(variant_npos); + } + + _Variadic_union<_Types...> _M_u; + using __index_type =3D __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 =3D static_cast<__index_type>(variant_npos); } + + constexpr bool + _M_valid() const noexcept + { + if constexpr (__variant::__never_valueless<_Types...>()) + return true; + + + + + + + return this->_M_index !=3D static_cast<__index_type>(variant_npos); + } + + _Variadic_union<_Types...> _M_u; + using __index_type =3D __select_index<_Types...>; + __index_type _M_index; + }; + + + template +=20=20=20 + inline void + __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args) + { + __v._M_reset(); + auto* __addr =3D std::__addressof(__variant::__get_n<_Np>(__v._M_u)); + std::_Construct(__addr, std::forward<_Args>(__args)...); + + __v._M_index =3D _Np; + } + + template + using _Variant_storage_alias =3D + _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>; + + + + + template + struct _Copy_ctor_base : _Variant_storage_alias<_Types...> + { + using _Base =3D _Variant_storage_alias<_Types...>; + using _Base::_Base; + +=20=20=20=20=20 + _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 =3D __rhs_index; + if constexpr (__j !=3D variant_npos) + std::_Construct(std::__addressof(this->_M_u), + in_place_index<__j>, __rhs_mem); + }, __variant_cast<_Types...>(__rhs)); + this->_M_index =3D __rhs._M_index; + } + + _Copy_ctor_base(_Copy_ctor_base&&) =3D default; + _Copy_ctor_base& operator=3D(const _Copy_ctor_base&) =3D default; + _Copy_ctor_base& operator=3D(_Copy_ctor_base&&) =3D default; + }; + + template + struct _Copy_ctor_base : _Variant_storage_alias<_Type= s...> + { + using _Base =3D _Variant_storage_alias<_Types...>; + using _Base::_Base; + }; + + template + using _Copy_ctor_alias =3D + _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>; + + template + struct _Move_ctor_base : _Copy_ctor_alias<_Types...> + { + using _Base =3D _Copy_ctor_alias<_Types...>; + using _Base::_Base; + +=20=20=20=20=20 + _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 =3D __rhs_index; + if constexpr (__j !=3D 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 =3D __rhs._M_index; + } + + _Move_ctor_base(const _Move_ctor_base&) =3D default; + _Move_ctor_base& operator=3D(const _Move_ctor_base&) =3D default; + _Move_ctor_base& operator=3D(_Move_ctor_base&&) =3D default; + }; + + template + struct _Move_ctor_base : _Copy_ctor_alias<_Types...> + { + using _Base =3D _Copy_ctor_alias<_Types...>; + using _Base::_Base; + }; + + template + using _Move_ctor_alias =3D + _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>; + + template + struct _Copy_assign_base : _Move_ctor_alias<_Types...> + { + using _Base =3D _Move_ctor_alias<_Types...>; + using _Base::_Base; + +=20=20=20=20=20 + _Copy_assign_base& + operator=3D(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 =3D __rhs_index; + if constexpr (__j =3D=3D variant_npos) + this->_M_reset(); + else if (this->_M_index =3D=3D __j) + __variant::__get<__j>(*this) =3D __rhs_mem; + else + { + using _Tj =3D 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 =3D variant<_Types...>; + _Variant& __self =3D __variant_cast<_Types...>(*this); + __self =3D _Variant(in_place_index<__j>, __rhs_mem); + } + } + }, __variant_cast<_Types...>(__rhs)); + return *this; + } + + _Copy_assign_base(const _Copy_assign_base&) =3D default; + _Copy_assign_base(_Copy_assign_base&&) =3D default; + _Copy_assign_base& operator=3D(_Copy_assign_base&&) =3D default; + }; + + template + struct _Copy_assign_base : _Move_ctor_alias<_Types...> + { + using _Base =3D _Move_ctor_alias<_Types...>; + using _Base::_Base; + }; + + template + using _Copy_assign_alias =3D + _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types= ...>; + + template + struct _Move_assign_base : _Copy_assign_alias<_Types...> + { + using _Base =3D _Copy_assign_alias<_Types...>; + using _Base::_Base; + +=20=20=20=20=20 + _Move_assign_base& + operator=3D(_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 =3D __rhs_index; + if constexpr (__j !=3D variant_npos) + { + if (this->_M_index =3D=3D __j) + __variant::__get<__j>(*this) =3D std::move(__rhs_mem); + else + { + using _Tj =3D 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 =3D variant<_Types...>; + _Variant& __self =3D __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&) =3D default; + _Move_assign_base(_Move_assign_base&&) =3D default; + _Move_assign_base& operator=3D(const _Move_assign_base&) =3D default; + }; + + template + struct _Move_assign_base : _Copy_assign_alias<_Types.= ..> + { + using _Base =3D _Copy_assign_alias<_Types...>; + using _Base::_Base; + }; + + template + using _Move_assign_alias =3D + _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types= ...>; + + template + struct _Variant_base : _Move_assign_alias<_Types...> + { + using _Base =3D _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&) =3D default; + _Variant_base(_Variant_base&&) =3D default; + _Variant_base& operator=3D(const _Variant_base&) =3D default; + _Variant_base& operator=3D(_Variant_base&&) =3D default; + }; + + template + inline constexpr bool __exactly_once + =3D std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Typ= es); + + + template struct _Arr { _Ti _M_x[1]; }; + + + template + struct _Build_FUN + { + + + void _S_fun() =3D 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 + =3D decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>())= ); + + + template + inline constexpr size_t + __accepted_index =3D variant_npos; + + template + inline constexpr size_t + __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>> + =3D _FUN_type<_Tp, _Variant>::value; + + template> + inline constexpr bool + __extra_visit_slot_needed =3D false; + + template + inline constexpr bool + __extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>> + =3D !__variant::__never_valueless<_Types...>(); + + template + inline constexpr bool + __extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types..= .>> + =3D !__variant::__never_valueless<_Types...>(); + + + template + struct _Multi_array; + + + template + struct _Multi_array<_Tp> + { + template + struct __untag_result + : false_type + { using element_type =3D _Tp; }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wignored-qualifiers" + template + struct __untag_result + : false_type + { using element_type =3D void(*)(_Args...); }; +#pragma GCC diagnostic pop + + template + struct __untag_result<__variant_cookie(*)(_Args...)> + : false_type + { using element_type =3D void(*)(_Args...); }; + + template + struct __untag_result<__variant_idx_cookie(*)(_Args...)> + : false_type + { using element_type =3D void(*)(_Args...); }; + + template + struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)> + : true_type + { using element_type =3D _Res(*)(_Args...); }; + + using __result_is_deduced =3D __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 =3D + sizeof...(_Variants) - sizeof...(__rest) - 1; + + using _Variant =3D typename _Nth_type<__index, _Variants...>::type; + + static constexpr int __do_cookie =3D + __extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0; + + using _Tp =3D _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]; + }; +# 921 "/usr/include/c++/13/variant" 3 + template + struct __gen_vtable_impl; +# 931 "/usr/include/c++/13/variant" 3 + template + struct __gen_vtable_impl< + _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>, + std::index_sequence<__indices...>> + { + using _Next =3D + remove_reference_t::type>; + using _Array_type =3D + _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 =3D nullptr) + { + if constexpr (__do_cookie) + { + __element =3D __gen_vtable_impl< + _Tp, + std::index_sequence<__indices..., __index>>::_S_apply(); + *__cookie_element =3D __gen_vtable_impl< + _Tp, + std::index_sequence<__indices..., variant_npos>>::_S_apply(); + } + else + { + auto __tmp_element =3D __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 =3D __tmp_element; + } + } + }; + + + + + template + struct __gen_vtable_impl< + _Multi_array<_Result_type (*)(_Visitor, _Variants...)>, + std::index_sequence<__indices...>> + { + using _Array_type =3D + _Multi_array<_Result_type (*)(_Visitor, _Variants...)>; + + template + static constexpr decltype(auto) + __element_by_index_or_cookie(_Variant&& __var) noexcept + { + if constexpr (__index !=3D 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 =3D + !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 =3D + _Multi_array<_Result_type (*)(_Visitor, _Variants...), + variant_size_v>...>; + + static constexpr _Array_type _S_vtable + =3D __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, __poison_hash>>... { }; + + + template())= ), + typename _Tp =3D variant_alternative_t<_Np, remove_reference_t<_AsV>= >> + using __get_t + =3D __conditional_t, _Tp&, _Tp&&>; + + + template + using __visit_result_t + =3D invoke_result_t<_Visitor, __get_t<0, _Variants>...>; + + template + constexpr inline bool __same_types =3D (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() =3D=3D 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"); + static_assert(!is_void_v<_Tp>, "_Tp must not be void"); + constexpr size_t __n =3D 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"); + static_assert(!is_void_v<_Tp>, "_Tp must not be void"); + constexpr size_t __n =3D 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"); + static_assert(!is_void_v<_Tp>, "_Tp must not be void"); + constexpr size_t __n =3D 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"); + static_assert(!is_void_v<_Tp>, "_Tp must not be void"); + constexpr size_t __n =3D 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 =3D variant_alternative_t<_Np, variant<_Type= s...>>; + 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() =3D=3D _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 =3D variant_alternative_t<_Np, variant<_Type= s...>>; + 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() =3D=3D _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 =3D 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 =3D std::__find_uniq_type_in_pack<_Tp, _Types..= .>(); + return std::get_if<__n>(__ptr); + } + + struct monostate { }; +# 1240 "/usr/include/c++/13/variant" 3 + template constexpr bool operator <(const variant<_Ty= pes...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true; __d= etail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto= __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) { if (= __lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rhs_ind= ex>(__lhs); __ret =3D __this_mem < __rhs_mem; } else __ret =3D (__lhs.index= () + 1) < (__rhs_index + 1); } else __ret =3D (__lhs.index() + 1) < (__rhs_= index + 1); }, __rhs); return __ret; } + template constexpr bool operator <=3D(const variant<= _Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true; = __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, a= uto __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) { i= f (__lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rhs_= index>(__lhs); __ret =3D __this_mem <=3D __rhs_mem; } else __ret =3D (__lhs= .index() + 1) <=3D (__rhs_index + 1); } else __ret =3D (__lhs.index() + 1) = <=3D (__rhs_index + 1); }, __rhs); return __ret; } + template constexpr bool operator =3D=3D(const varian= t<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true= ; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem,= auto __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) {= if (__lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rh= s_index>(__lhs); __ret =3D __this_mem =3D=3D __rhs_mem; } else __ret =3D (_= _lhs.index() + 1) =3D=3D (__rhs_index + 1); } else __ret =3D (__lhs.index()= + 1) =3D=3D (__rhs_index + 1); }, __rhs); return __ret; } + template constexpr bool operator !=3D(const variant<= _Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true; = __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, a= uto __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) { i= f (__lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rhs_= index>(__lhs); __ret =3D __this_mem !=3D __rhs_mem; } else __ret =3D (__lhs= .index() + 1) !=3D (__rhs_index + 1); } else __ret =3D (__lhs.index() + 1) = !=3D (__rhs_index + 1); }, __rhs); return __ret; } + template constexpr bool operator >=3D(const variant<= _Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true; = __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, a= uto __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) { i= f (__lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rhs_= index>(__lhs); __ret =3D __this_mem >=3D __rhs_mem; } else __ret =3D (__lhs= .index() + 1) >=3D (__rhs_index + 1); } else __ret =3D (__lhs.index() + 1) = >=3D (__rhs_index + 1); }, __rhs); return __ret; } + template constexpr bool operator >(const variant<_Ty= pes...>& __lhs, const variant<_Types...>& __rhs) { bool __ret =3D true; __d= etail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto= __rhs_index) mutable { if constexpr (__rhs_index !=3D variant_npos) { if (= __lhs.index() =3D=3D __rhs_index) { auto& __this_mem =3D std::get<__rhs_ind= ex>(__lhs); __ret =3D __this_mem > __rhs_mem; } else __ret =3D (__lhs.index= () + 1) > (__rhs_index + 1); } else __ret =3D (__lhs.index() + 1) > (__rhs_= index + 1); }, __rhs); return __ret; } + + + + constexpr bool operator=3D=3D(monostate, monostate) noexcept { return tr= ue; } +# 1281 "/usr/include/c++/13/variant" 3 + constexpr bool operator!=3D(monostate, monostate) noexcept { return fals= e; } + constexpr bool operator<(monostate, monostate) noexcept { return false; } + constexpr bool operator>(monostate, monostate) noexcept { return false; } + constexpr bool operator<=3D(monostate, monostate) noexcept { return true= ; } + constexpr bool operator>=3D(monostate, monostate) noexcept { return true= ; } + + + template + constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...> + visit(_Visitor&&, _Variants&&...); + + template +=20=20=20 + 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...>&) =3D delete; + + 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 =3D "bad variant access"; + + friend void __throw_bad_variant_access(const char* __what); + }; + + + inline void + __throw_bad_variant_access(const char* __what) + { (__builtin_abort()); } + + inline void + __throw_bad_variant_access(bool __valueless) + { + if (__valueless) [[__unlikely__]] + __throw_bad_variant_access("std::get: variant is valueless"); + else + __throw_bad_variant_access("std::get: wrong index for variant"); + } + + template + class variant + : private __detail::__variant::_Variant_base<_Types...>, + private _Enable_default_constructor< + __detail::__variant::_Traits<_Types...>::_S_default_ctor, + variant<_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_reference_v<_Types> || ...), + "variant must have no reference alternative"); + static_assert(!(std::is_void_v<_Types> || ...), + "variant must have no void alternative"); + + using _Base =3D __detail::__variant::_Variant_base<_Types...>; + using _Default_ctor_enabler =3D + _Enable_default_constructor< + __detail::__variant::_Traits<_Types...>::_S_default_ctor, + variant<_Types...>>; + + template + static constexpr bool __not_self + =3D !is_same_v<__remove_cvref_t<_Tp>, variant>; + + template + static constexpr bool + __exactly_once =3D __detail::__variant::__exactly_once<_Tp, _Types...>; + + template + static constexpr size_t __accepted_index + =3D __detail::__variant::__accepted_index<_Tp, variant>; + + template> + using __to_type =3D typename _Nth_type<_Np, _Types...>::type; + + template>> + using __accepted_type =3D __to_type<__accepted_index<_Tp>>; + + template + static constexpr size_t __index_of + =3D std::__find_uniq_type_in_pack<_Tp, _Types...>(); + + using _Traits =3D __detail::__variant::_Traits<_Types...>; + + template + struct __is_in_place_tag : false_type { }; + template + struct __is_in_place_tag> : true_type { }; + template + struct __is_in_place_tag> : true_type { }; + + template + static constexpr bool __not_in_place_tag + =3D !__is_in_place_tag<__remove_cvref_t<_Tp>>::value; + + public: + variant() =3D default; + variant(const variant& __rhs) =3D default; + variant(variant&&) =3D default; + variant& operator=3D(const variant&) =3D default; + variant& operator=3D(variant&&) =3D default; + ~variant() =3D default; + + template, + typename =3D enable_if_t<__not_in_place_tag<_Tp>>, + typename _Tj =3D __accepted_type<_Tp&&>, + typename =3D 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 =3D enable_if_t>> + constexpr explicit + variant(in_place_index_t<_Np>, _Args&&... __args) + : _Base(in_place_index<_Np>, std::forward<_Args>(__args)...), + _Default_ctor_enabler(_Enable_default_constructor_tag{}) + { } + + template, + typename =3D 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)...), + _Default_ctor_enabler(_Enable_default_constructor_tag{}) + { } + + 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=3D(_Tp&& __rhs) + noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp> + && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>) + { + constexpr auto __index =3D __accepted_index<_Tp>; + if (index() =3D=3D __index) + std::get<__index>(*this) =3D std::forward<_Tp>(__rhs); + else + { + using _Tj =3D __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 =3D __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 =3D __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 =3D std::__detail::__variant; + using type =3D 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 =3D 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 =3D std::__detail::__variant; + using type =3D 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 =3D std::move(__tmp); + } + else + { + + + __variant::__emplace<_Np>(*this, __il, + std::forward<_Args>(__args)...); + } + return std::get<_Np>(*this); + } + + template + enable_if_t emplace(_Args&&...) =3D delete; + + template + enable_if_t> emplace(_Args&&...) =3D delete; + + constexpr bool valueless_by_exception() const noexcept + { return !this->_M_valid(); } + + constexpr size_t index() const noexcept + { + using __index_type =3D typename _Base::__index_type; + if constexpr (__detail::__variant::__never_valueless<_Types...>()) + return this->_M_index; + else if constexpr (sizeof...(_Types) <=3D __index_type(-1) / 2) + return make_signed_t<__index_type>(this->_M_index); + else + return size_t(__index_type(this->_M_index + 1)) - 1; + } + +=20=20=20=20=20 + 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 =3D __detail::__variant; + + __variant::__raw_idx_visit( + [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable + { + constexpr size_t __j =3D __rhs_index; + if constexpr (__j !=3D variant_npos) + { + if (this->index() =3D=3D __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 =3D std::move(*this); + else + __variant::__raw_idx_visit( + [&__rhs](auto&& __this_mem, auto __this_index) mutable + { + constexpr size_t __k =3D __this_index; + if constexpr (__k !=3D variant_npos) + __variant::__emplace<__k>(__rhs, + std::move(__this_mem)); + }, *this); + + __variant::__emplace<__j>(*this, std::move(__tmp)); + } + } + }, __rhs); + } + + + + + + + private: + template + friend constexpr decltype(auto) + __detail::__variant::__get(_Vp&& __v) noexcept; + + + + + + + + template friend constexpr bool operator <(const var= iant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + template friend constexpr bool operator <=3D(const = variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + template friend constexpr bool operator =3D=3D(cons= t variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + template friend constexpr bool operator !=3D(const = variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + template friend constexpr bool operator >=3D(const = variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + template friend constexpr bool operator >(const var= iant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); + + + }; + + 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() !=3D _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() !=3D _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() !=3D _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() !=3D _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) =3D=3D 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 =3D 11; + + + using _V0 =3D typename _Nth_type<0, _Variants...>::type; + + constexpr auto __n =3D variant_size_v>; + + if constexpr (sizeof...(_Variants) > 1 || __n > __max) + { + + constexpr auto& __vtable =3D __detail::__variant::__gen_vtable< + _Result_type, _Visitor&&, _Variants&&...>::_S_vtable; + + auto __func_ptr =3D __vtable._M_access(__variants.index()...); + return (*__func_ptr)(std::forward<_Visitor>(__visitor), + std::forward<_Variants>(__variants)...); + } + else + { + + _V0& __v0 + =3D [](_V0& __v, ...) -> _V0& { return __v; }(__variants...); + + using __detail::__variant::_Multi_array; + using __detail::__variant::__gen_vtable_impl; + using _Ma =3D _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>; +# 1789 "/usr/include/c++/13/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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_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::forw= ard<_V0>(__v0)); } else __builtin_unreachable(); } + case 10: { if constexpr (10 < __n) { return __gen_vtable_impl<_Ma, ind= ex_sequence<10>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::f= orward<_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 =3D 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 =3D std::__detail::__variant; + + if ((__variant::__as(__variants).valueless_by_exception() || ...)) + __throw_bad_variant_access("std::visit: variant is valueless"); + + using _Result_type + =3D __detail::__variant::__visit_result_t<_Visitor, _Variants...>; + + using _Tag =3D __detail::__variant::__deduce_visit_result<_Result_ty= pe>; + + if constexpr (sizeof...(_Variants) =3D=3D 1) + { + using _Vp =3D decltype(__variant::__as(std::declval<_Variants>()...)); + + constexpr bool __visit_rettypes_match =3D __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))...); + } +# 1880 "/usr/include/c++/13/variant" 3 + template + struct __variant_hash_call_base_impl + { + 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 =3D __remove_cvref_t; + if constexpr (!is_same_v<_Type, + __detail::__variant::__variant_cookie>) + __ret =3D std::hash{}(__t.index()) + + std::hash<_Type>{}(__t_mem); + else + __ret =3D std::hash{}(__t.index()); + }, __t); + return __ret; + } + }; + + template + struct __variant_hash_call_base_impl {}; + + template + using __variant_hash_call_base =3D + __variant_hash_call_base_impl<(__poison_hash>:: + __enable_hash_call &&...), _Types...>; + + + template + struct hash> + : private __detail::__variant::_Variant_hash_base< + variant<_Types...>, std::index_sequence_for<_Types...>>, + public __variant_hash_call_base<_Types...> + { + using result_type [[__deprecated__]] =3D size_t; + using argument_type [[__deprecated__]] =3D variant<_Types...>; + }; + + template<> + struct hash + { + using result_type [[__deprecated__]] =3D size_t; + using argument_type [[__deprecated__]] =3D monostate; + + size_t + operator()(const monostate&) const noexcept + { + constexpr size_t __magic_monostate_hash =3D -7777; + return __magic_monostate_hash; + } + }; + + template + struct __is_fast_hash>> + : bool_constant<(__is_fast_hash<_Types>::value && ...)> + { }; + + +} +# 2402 "/usr/include/gtest/internal/gtest-port.h" 2 3 4 +namespace testing { +namespace internal { +template +using Variant =3D ::std::variant; +} +} +# 56 "/usr/include/gtest/gtest-message.h" 2 3 4 + + + + + + +void operator<<(const testing::internal::Secret&, int); + +namespace testing { +# 92 "/usr/include/gtest/gtest-message.h" 3 4 +class __attribute__((visibility("default"))) Message { + private: + + + typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); + + public: + + Message(); + + + Message(const Message& msg) : ss_(new ::std::stringstream) { + *ss_ << msg.GetString(); + } + + + explicit Message(const char* str) : ss_(new ::std::stringstream) { + *ss_ << str; + } + + + template + inline Message& operator<<(const T& val) { +# 129 "/usr/include/gtest/gtest-message.h" 3 4 + using ::operator<<; + *ss_ << val; + return *this; + } +# 147 "/usr/include/gtest/gtest-message.h" 3 4 + template + inline Message& operator<<(T* const& pointer) { + if (pointer =3D=3D nullptr) { + *ss_ << "(null)"; + } else { + *ss_ << pointer; + } + return *this; + } + + + + + + + + Message& operator<<(BasicNarrowIoManip val) { + *ss_ << val; + return *this; + } + + + Message& operator<<(bool b) { return *this << (b ? "true" : "false"); } + + + + Message& operator<<(const wchar_t* wide_c_str); + Message& operator<<(wchar_t* wide_c_str); + + + + + Message& operator<<(const ::std::wstring& wstr); + + + + + + + std::string GetString() const; + + private: + + const std::unique_ptr< ::std::stringstream> ss_; + + + + void operator=3D(const Message&); +}; + + +inline std::ostream& operator<<(std::ostream& os, const Message& sb) { + return os << sb.GetString(); +} + +namespace internal { + + + + + +template +std::string StreamableToString(const T& streamable) { + return (Message() << streamable).GetString(); +} + +} +} + + +# 47 "/usr/include/gtest/gtest-assertion-result.h" 2 3 4 + + + + + +namespace testing { +# 133 "/usr/include/gtest/gtest-assertion-result.h" 3 4 +class __attribute__((visibility("default"))) AssertionResult { + public: + + + AssertionResult(const AssertionResult& other); +# 154 "/usr/include/gtest/gtest-assertion-result.h" 3 4 + template + explicit AssertionResult( + const T& success, + typename std::enable_if< + !std::is_convertible::value>::type* + + =3D nullptr) + : success_(success) {} + + + + + + + AssertionResult& operator=3D(AssertionResult other) { + swap(other); + return *this; + } + + + operator bool() const { return success_; } + + + AssertionResult operator!() const; + + + + + + const char* message() const { + return message_.get() !=3D nullptr ? message_->c_str() : ""; + } + + const char* failure_message() const { return message(); } + + + template + AssertionResult& operator<<(const T& value) { + AppendMessage(Message() << value); + return *this; + } + + + + AssertionResult& operator<<( + ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { + AppendMessage(Message() << basic_manipulator); + return *this; + } + + private: + + void AppendMessage(const Message& a_message) { + if (message_.get() =3D=3D nullptr) message_.reset(new ::std::string); + message_->append(a_message.GetString().c_str()); + } + + + void swap(AssertionResult& other); + + + bool success_; + + + + + std::unique_ptr< ::std::string> message_; +}; + + +__attribute__((visibility("default"))) AssertionResult AssertionSuccess(); + + +__attribute__((visibility("default"))) AssertionResult AssertionFailure(); + + + +__attribute__((visibility("default"))) AssertionResult AssertionFailure(co= nst Message& msg); + +} + + +# 60 "/usr/include/gtest/gtest.h" 2 3 4 +# 1 "/usr/include/gtest/gtest-death-test.h" 1 3 4 +# 43 "/usr/include/gtest/gtest-death-test.h" 3 4 +# 1 "/usr/include/gtest/internal/gtest-death-test-internal.h" 1 3 4 +# 46 "/usr/include/gtest/internal/gtest-death-test-internal.h" 3 4 +# 1 "/usr/include/gtest/gtest-matchers.h" 1 3 4 +# 42 "/usr/include/gtest/gtest-matchers.h" 3 4 +# 1 "/usr/include/c++/13/atomic" 1 3 4 +# 35 "/usr/include/c++/13/atomic" 3 4 +=20=20=20=20=20=20=20 +# 36 "/usr/include/c++/13/atomic" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/13/atomic" 3 + template + struct atomic; + + + + template<> + struct atomic + { + using value_type =3D bool; + + private: + __atomic_base _M_base; + + public: + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(bool __i) noexcept : _M_base(__i) { } + + bool + operator=3D(bool __i) noexcept + { return _M_base.operator=3D(__i); } + + bool + operator=3D(bool __i) volatile noexcept + { return _M_base.operator=3D(__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 =3D 1 =3D=3D 2; + + + void + store(bool __i, memory_order __m =3D memory_order_seq_cst) noexcept + { _M_base.store(__i, __m); } + + void + store(bool __i, memory_order __m =3D memory_order_seq_cst) volatile no= except + { _M_base.store(__i, __m); } + + bool + load(memory_order __m =3D memory_order_seq_cst) const noexcept + { return _M_base.load(__m); } + + bool + load(memory_order __m =3D memory_order_seq_cst) const volatile noexcept + { return _M_base.load(__m); } + + bool + exchange(bool __i, memory_order __m =3D memory_order_seq_cst) noexcept + { return _M_base.exchange(__i, __m); } + + bool + exchange(bool __i, + memory_order __m =3D 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 =3D 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 =3D 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 =3D 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 =3D memory_order_seq_cst) volatile noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } +# 182 "/usr/include/c++/13/atomic" 3 + }; +# 197 "/usr/include/c++/13/atomic" 3 + template + struct atomic + { + using value_type =3D _Tp; + + private: + + static constexpr int _S_min_alignment + =3D (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 + ? 0 : sizeof(_Tp); + + static constexpr int _S_alignment + =3D _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"); +# 226 "/usr/include/c++/13/atomic" 3 + public: + atomic() =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D 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=3D(_Tp __i) noexcept + { store(__i); return __i; } + + _Tp + operator=3D(_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 + =3D __atomic_always_lock_free(sizeof(_M_i), 0); + + + void + store(_Tp __i, memory_order __m =3D 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 =3D memory_order_seq_cst) volatile n= oexcept + { + __atomic_store(std::__addressof(_M_i), + __atomic_impl::__clear_padding(__i), + int(__m)); + } + + _Tp + load(memory_order __m =3D memory_order_seq_cst) const noexcept + { + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + _Tp* __ptr =3D reinterpret_cast<_Tp*>(__buf); + __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); + return *__ptr; + } + + _Tp + load(memory_order __m =3D memory_order_seq_cst) const volatile noexc= ept + { + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + _Tp* __ptr =3D reinterpret_cast<_Tp*>(__buf); + __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); + return *__ptr; + } + + _Tp + exchange(_Tp __i, memory_order __m =3D memory_order_seq_cst) noexcept + { + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + _Tp* __ptr =3D 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 =3D memory_order_seq_cst) volatile noexcept + { + alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; + _Tp* __ptr =3D 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 =3D 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 =3D 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 =3D 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 =3D memory_order_seq_cst) volatile noexcept + { return compare_exchange_strong(__e, __i, __m, + __cmpexch_failure_order(__m)); } +# 408 "/usr/include/c++/13/atomic" 3 + }; + + + + template + struct atomic<_Tp*> + { + using value_type =3D _Tp*; + using difference_type =3D ptrdiff_t; + + typedef _Tp* __pointer_type; + typedef __atomic_base<_Tp*> __base_type; + __base_type _M_b; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D 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=3D(__pointer_type __p) noexcept + { return _M_b.operator=3D(__p); } + + __pointer_type + operator=3D(__pointer_type __p) volatile noexcept + { return _M_b.operator=3D(__p); } + + __pointer_type + operator++(int) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b++; + } + + __pointer_type + operator++(int) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b++; + } + + __pointer_type + operator--(int) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b--; + } + + __pointer_type + operator--(int) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b--; + } + + __pointer_type + operator++() noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return ++_M_b; + } + + __pointer_type + operator++() volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return ++_M_b; + } + + __pointer_type + operator--() noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return --_M_b; + } + + __pointer_type + operator--() volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return --_M_b; + } + + __pointer_type + operator+=3D(ptrdiff_t __d) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.operator+=3D(__d); + } + + __pointer_type + operator+=3D(ptrdiff_t __d) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.operator+=3D(__d); + } + + __pointer_type + operator-=3D(ptrdiff_t __d) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.operator-=3D(__d); + } + + __pointer_type + operator-=3D(ptrdiff_t __d) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.operator-=3D(__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 + =3D 2 =3D=3D 2; + + + void + store(__pointer_type __p, + memory_order __m =3D memory_order_seq_cst) noexcept + { return _M_b.store(__p, __m); } + + void + store(__pointer_type __p, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { return _M_b.store(__p, __m); } + + __pointer_type + load(memory_order __m =3D memory_order_seq_cst) const noexcept + { return _M_b.load(__m); } + + __pointer_type + load(memory_order __m =3D memory_order_seq_cst) const volatile noexc= ept + { return _M_b.load(__m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m =3D memory_order_seq_cst) noexcept + { return _M_b.exchange(__p, __m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m =3D 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 =3D 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 =3D 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 =3D 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 =3D memory_order_seq_cst) volatile noexcept + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } +# 663 "/usr/include/c++/13/atomic" 3 + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.fetch_add(__d, __m); + } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.fetch_add(__d, __m); + } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) noexcept + { + + static_assert( is_object<_Tp>::value, "pointer to object type" ); + + return _M_b.fetch_sub(__d, __m); + } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m =3D memory_order_seq_cst) volatile noexcept + { + + static_assert( is_object<_Tp>::value, "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 =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef signed char __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept=3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned char __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept=3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef short __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned short __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef int __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned int __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef long long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef unsigned long long __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef wchar_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free =3D 2 =3D=3D 2; + + }; +# 1008 "/usr/include/c++/13/atomic" 3 + template<> + struct atomic : __atomic_base + { + typedef char16_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free + =3D 1 =3D=3D 2; + + }; + + + template<> + struct atomic : __atomic_base + { + typedef char32_t __integral_type; + typedef __atomic_base __base_type; + + atomic() noexcept =3D default; + ~atomic() noexcept =3D default; + atomic(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) =3D delete; + atomic& operator=3D(const atomic&) volatile =3D delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=3D; + + + static constexpr bool is_always_lock_free + =3D 2 =3D=3D 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); } +# 1237 "/usr/include/c++/13/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); } +# 1284 "/usr/include/c++/13/atomic" 3 + template + using __atomic_val_t =3D __type_identity_t<_Tp>; + template + using __atomic_diff_t =3D 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) noex= cept + { __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) noexce= pt + { 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) noe= xcept + { 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); + } +# 1490 "/usr/include/c++/13/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); } +# 1790 "/usr/include/c++/13/atomic" 3 + +} +# 43 "/usr/include/gtest/gtest-matchers.h" 2 3 4 + + + + + +# 1 "/usr/include/gtest/gtest-printers.h" 1 3 4 +# 104 "/usr/include/gtest/gtest-printers.h" 3 4 +# 1 "/usr/include/c++/13/functional" 1 3 4 +# 46 "/usr/include/c++/13/functional" 3 4 +=20=20=20=20=20=20=20 +# 47 "/usr/include/c++/13/functional" 3 +# 59 "/usr/include/c++/13/functional" 3 +# 1 "/usr/include/c++/13/bits/std_function.h" 1 3 +# 33 "/usr/include/c++/13/bits/std_function.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/std_function.h" 3 +# 45 "/usr/include/c++/13/bits/std_function.h" 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 =3D sizeof(_Nocopy_types); + static const size_t _M_max_align =3D __alignof__(_Nocopy_types); + + template + class _Base_manager + { + protected: + static const bool __stored_locally =3D + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <=3D _M_max_size + && __alignof__(_Functor) <=3D _M_max_align + && (_M_max_align % __alignof__(_Functor) =3D=3D 0)); + + using _Local_storage =3D integral_constant; + + + static _Functor* + _M_get_pointer(const _Any_data& __source) noexcept + { + if constexpr (__stored_locally) + { + const _Functor& __f =3D __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*>() + =3D 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() =3D &typeid(_Functor); + + + + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() =3D _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 !=3D nullptr; } + + template + static bool + _M_not_empty_function(_Tp _Class::* __mp) noexcept + { return __mp !=3D nullptr; } + + template + static bool + _M_not_empty_function(const _Tp&) noexcept + { return true; } + }; + + _Function_base() =3D default; + + ~_Function_base() + { + if (_M_manager) + _M_manager(_M_functor, _M_functor, __destroy_functor); + } + + bool _M_empty() const { return !_M_manager; } + + using _Manager_type + =3D 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 =3D _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() =3D &typeid(_Functor); + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() =3D _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 + =3D typename __enable_if_t>::type; + + template, + typename _Res2 =3D __invoke_result<_DFunc&, _ArgTypes...>> + struct _Callable + : __is_invocable_impl<_Res2, _Res>::type + { }; + + template + using _Requires =3D __enable_if_t<_Cond::value, _Tp>; + + template + using _Handler + =3D _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>; + + public: + typedef _Res result_type; + + + + + + + + function() noexcept + : _Function_base() { } + + + + + + function(nullptr_t) noexcept + : _Function_base() { } +# 386 "/usr/include/c++/13/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 =3D __x._M_invoker; + _M_manager =3D __x._M_manager; + } + } +# 404 "/usr/include/c++/13/bits/std_function.h" 3 + function(function&& __x) noexcept + : _Function_base(), _M_invoker(__x._M_invoker) + { + if (static_cast(__x)) + { + _M_functor =3D __x._M_functor; + _M_manager =3D __x._M_manager; + __x._M_manager =3D nullptr; + __x._M_invoker =3D nullptr; + } + } +# 433 "/usr/include/c++/13/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 =3D _Handler<_Functor>; + + if (_My_handler::_M_not_empty_function(__f)) + { + _My_handler::_M_init_functor(_M_functor, + std::forward<_Functor>(__f)); + _M_invoker =3D &_My_handler::_M_invoke; + _M_manager =3D &_My_handler::_M_manager; + } + } +# 468 "/usr/include/c++/13/bits/std_function.h" 3 + function& + operator=3D(const function& __x) + { + function(__x).swap(*this); + return *this; + } +# 486 "/usr/include/c++/13/bits/std_function.h" 3 + function& + operator=3D(function&& __x) noexcept + { + function(std::move(__x)).swap(*this); + return *this; + } +# 500 "/usr/include/c++/13/bits/std_function.h" 3 + function& + operator=3D(nullptr_t) noexcept + { + if (_M_manager) + { + _M_manager(_M_functor, _M_functor, __destroy_functor); + _M_manager =3D nullptr; + _M_invoker =3D nullptr; + } + return *this; + } +# 529 "/usr/include/c++/13/bits/std_function.h" 3 + template + _Requires<_Callable<_Functor>, function&> + operator=3D(_Functor&& __f) + noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) + { + function(std::forward<_Functor>(__f)).swap(*this); + return *this; + } + + + template + function& + operator=3D(reference_wrapper<_Functor> __f) noexcept + { + function(__f).swap(*this); + return *this; + } +# 556 "/usr/include/c++/13/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); + } +# 573 "/usr/include/c++/13/bits/std_function.h" 3 + explicit operator bool() const noexcept + { return !_M_empty(); } +# 586 "/usr/include/c++/13/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)...); + } +# 605 "/usr/include/c++/13/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 =3D __typeinfo_result._M_access()) + return *__ti; + } + return typeid(void); + } +# 630 "/usr/include/c++/13/bits/std_function.h" 3 + template + _Functor* + target() noexcept + { + const function* __const_this =3D this; + const _Functor* __func =3D __const_this->template target<_Functor>(); + + + return *const_cast<_Functor**>(&__func); + } + + template + const _Functor* + target() const noexcept + { + if constexpr (is_object<_Functor>::value) + { + + + using _Handler =3D _Target_handler<_Res(_ArgTypes...), _Functor>; + + if (_M_manager =3D=3D &_Handler::_M_manager + + || (_M_manager && typeid(_Functor) =3D=3D target_type()) + + ) + { + _Any_data __ptr; + _M_manager(__ptr, _M_functor, __get_functor_ptr); + return __ptr._M_access(); + } + } + return nullptr; + } + + + private: + using _Invoker_type =3D _Res (*)(const _Any_data&, _ArgTypes&&...); + _Invoker_type _M_invoker =3D nullptr; + }; + + + template + struct __function_guide_helper + { }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) noexcept(_Nx) + > + { using type =3D _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) & noexcept(_Nx) + > + { using type =3D _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) const noexcept(_Nx) + > + { using type =3D _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) const & noexcept(_Nx) + > + { using type =3D _Res(_Args...); }; +# 715 "/usr/include/c++/13/bits/std_function.h" 3 + template + using __function_guide_t =3D typename __function_guide_helper<_Op>::ty= pe; + + + template + function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; + + template> + function(_Fn) -> function<_Signature>; +# 735 "/usr/include/c++/13/bits/std_function.h" 3 + template + inline bool + operator=3D=3D(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return !static_cast(__f); } + + + + template + inline bool + operator=3D=3D(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return !static_cast(__f); } + + + + + + + + template + inline bool + operator!=3D(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return static_cast(__f); } + + + template + inline bool + operator!=3D(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return static_cast(__f); } +# 774 "/usr/include/c++/13/bits/std_function.h" 3 + template + inline void + swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noe= xcept + { __x.swap(__y); } + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 60 "/usr/include/c++/13/functional" 2 3 + + + +# 1 "/usr/include/c++/13/unordered_map" 1 3 +# 32 "/usr/include/c++/13/unordered_map" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/unordered_map" 3 +# 41 "/usr/include/c++/13/unordered_map" 3 +# 1 "/usr/include/c++/13/bits/unordered_map.h" 1 3 +# 33 "/usr/include/c++/13/bits/unordered_map.h" 3 +# 1 "/usr/include/c++/13/bits/hashtable.h" 1 3 +# 33 "/usr/include/c++/13/bits/hashtable.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/hashtable.h" 3 + +# 1 "/usr/include/c++/13/bits/hashtable_policy.h" 1 3 +# 42 "/usr/include/c++/13/bits/hashtable_policy.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class _Hashtable; + +namespace __detail +{ + + + + + + template + struct _Hashtable_base; + + + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::input_iterator_tag) + { return __first !=3D __last ? 1 : 0; } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::forward_iterator_tag) + { return std::distance(__first, __last); } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last) + { return __distance_fw(__first, __last, + std::__iterator_category(__first)); } + + 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 =3D _Tp; }; + + template + struct __1st_type> + { using type =3D const _Tp; }; + + template + struct __1st_type<_Pair&> + { using type =3D typename __1st_type<_Pair>::type&; }; + + template + typename __1st_type<_Tp>::type&& + operator()(_Tp&& __x) const noexcept + { return std::forward<_Tp>(__x).first; } + }; + + template + struct _ConvertToValueType; + + template + struct _ConvertToValueType<_Identity, _Value> + { + template + constexpr _Kt&& + operator()(_Kt&& __k) const noexcept + { return std::forward<_Kt>(__k); } + }; + + template + struct _ConvertToValueType<_Select1st, _Value> + { + constexpr _Value&& + operator()(_Value&& __x) const noexcept + { return std::move(__x); } + + constexpr const _Value& + operator()(const _Value& __x) const noexcept + { return __x; } + + template + constexpr std::pair<_Kt, _Val>&& + operator()(std::pair<_Kt, _Val>&& __x) const noexcept + { return std::move(__x); } + + template + constexpr const std::pair<_Kt, _Val>& + operator()(const std::pair<_Kt, _Val>& __x) const noexcept + { return __x; } + }; + + template + struct _NodeBuilder; + + template<> + struct _NodeBuilder<_Select1st> + { + template + static auto + _S_build(_Kt&& __k, _Arg&& __arg, const _NodeGenerator& __node_gen) + -> typename _NodeGenerator::__node_type* + { + return __node_gen(std::forward<_Kt>(__k), + std::forward<_Arg>(__arg).second); + } + }; + + template<> + struct _NodeBuilder<_Identity> + { + template + static auto + _S_build(_Kt&& __k, _Arg&&, const _NodeGenerator& __node_gen) + -> typename _NodeGenerator::__node_type* + { return __node_gen(std::forward<_Kt>(__k)); } + }; + + template + struct _Hashtable_alloc; + + + + template + struct _ReuseOrAllocNode + { + private: + using __node_alloc_type =3D _NodeAlloc; + using __hashtable_alloc =3D _Hashtable_alloc<__node_alloc_type>; + using __node_alloc_traits =3D + typename __hashtable_alloc::__node_alloc_traits; + + public: + using __node_type =3D typename __hashtable_alloc::__node_type; + + _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) + : _M_nodes(__nodes), _M_h(__h) { } + _ReuseOrAllocNode(const _ReuseOrAllocNode&) =3D delete; + + ~_ReuseOrAllocNode() + { _M_h._M_deallocate_nodes(_M_nodes); } + + template + __node_type* + operator()(_Args&&... __args) const + { + if (_M_nodes) + { + __node_type* __node =3D _M_nodes; + _M_nodes =3D _M_nodes->_M_next(); + __node->_M_nxt =3D nullptr; + auto& __a =3D _M_h._M_node_allocator(); + __node_alloc_traits::destroy(__a, __node->_M_valptr()); + if (true) + { + __node_alloc_traits::construct(__a, __node->_M_valptr(), + std::forward<_Args>(__args)...); + } + if (false) + { + _M_h._M_deallocate_node_ptr(__node); + ; + } + return __node; + } + return _M_h._M_allocate_node(std::forward<_Args>(__args)...); + } + + private: + mutable __node_type* _M_nodes; + __hashtable_alloc& _M_h; + }; + + + + template + struct _AllocNode + { + private: + using __hashtable_alloc =3D _Hashtable_alloc<_NodeAlloc>; + + public: + using __node_type =3D typename __hashtable_alloc::__node_type; + + _AllocNode(__hashtable_alloc& __h) + : _M_h(__h) { } + + template + __node_type* + operator()(_Args&&... __args) const + { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); } + + private: + __hashtable_alloc& _M_h; + }; +# 279 "/usr/include/c++/13/bits/hashtable_policy.h" 3 + template + struct _Hashtable_traits + { + using __hash_cached =3D __bool_constant<_Cache_hash_code>; + using __constant_iterators =3D __bool_constant<_Constant_iterators>; + using __unique_keys =3D __bool_constant<_Unique_keys>; + }; + + + + + + + + template + struct _Hashtable_hash_traits + { + static constexpr std::size_t + __small_size_threshold() noexcept + { return std::__is_fast_hash<_Hash>::value ? 0 : 20; } + }; +# 309 "/usr/include/c++/13/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 + { + typedef _Value value_type; + + __gnu_cxx::__aligned_buffer<_Value> _M_storage; + + _Value* + _M_valptr() noexcept + { return _M_storage._M_ptr(); } + + const _Value* + _M_valptr() const noexcept + { return _M_storage._M_ptr(); } + + _Value& + _M_v() noexcept + { return *_M_valptr(); } + + const _Value& + _M_v() const noexcept + { return *_M_valptr(); } + }; + + + + + template + struct _Hash_node_code_cache + { }; + + + + + template<> + struct _Hash_node_code_cache + { std::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 =3D _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 =3D _M_cur->_M_next(); } + + friend bool + operator=3D=3D(const _Node_iterator_base& __x, const _Node_iterator_= base& __y) + noexcept + { return __x._M_cur =3D=3D __y._M_cur; } + + + friend bool + operator!=3D(const _Node_iterator_base& __x, const _Node_iterator_ba= se& __y) + noexcept + { return __x._M_cur !=3D __y._M_cur; } + + }; + + + template + struct _Node_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type =3D _Node_iterator_base<_Value, __cache>; + using __node_type =3D typename __base_type::__node_type; + + public: + using value_type =3D _Value; + using difference_type =3D std::ptrdiff_t; + using iterator_category =3D std::forward_iterator_tag; + + using pointer =3D __conditional_t<__constant_iterators, + const value_type*, value_type*>; + + using reference =3D __conditional_t<__constant_iterators, + const value_type&, value_type&>; + + _Node_iterator() =3D 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; + } + }; + + + template + struct _Node_const_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type =3D _Node_iterator_base<_Value, __cache>; + using __node_type =3D typename __base_type::__node_type; + + public: + typedef _Value value_type; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + typedef const value_type* pointer; + typedef const value_type& reference; + + _Node_const_iterator() =3D default; + + explicit + _Node_const_iterator(__node_type* __p) noexcept + : __base_type(__p) { } + + _Node_const_iterator(const _Node_iterator<_Value, __constant_iterato= rs, + __cache>& __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; + } + }; + + + + + + + struct _Mod_range_hashing + { + typedef std::size_t first_argument_type; + typedef std::size_t second_argument_type; + typedef std::size_t result_type; + + result_type + operator()(first_argument_type __num, + second_argument_type __den) const noexcept + { return __num % __den; } + }; + + + + + + + struct _Default_ranged_hash { }; + + + + struct _Prime_rehash_policy + { + using __has_load_factor =3D true_type; + + _Prime_rehash_policy(float __z =3D 1.0) noexcept + : _M_max_load_factor(__z), _M_next_resize(0) { } + + float + max_load_factor() const noexcept + { return _M_max_load_factor; } + + + std::size_t + _M_next_bkt(std::size_t __n) const; + + + std::size_t + _M_bkt_for_elements(std::size_t __n) const + { return __builtin_ceil(__n / (double)_M_max_load_factor); } + + + + + + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) const; + + typedef std::size_t _State; + + _State + _M_state() const + { return _M_next_resize; } + + void + _M_reset() noexcept + { _M_next_resize =3D 0; } + + void + _M_reset(_State __state) + { _M_next_resize =3D __state; } + + static const std::size_t _S_growth_factor =3D 2; + + float _M_max_load_factor; + mutable std::size_t _M_next_resize; + }; + + + struct _Mask_range_hashing + { + typedef std::size_t first_argument_type; + typedef std::size_t second_argument_type; + typedef std::size_t result_type; + + result_type + operator()(first_argument_type __num, + second_argument_type __den) const noexcept + { return __num & (__den - 1); } + }; + + + inline std::size_t + __clp2(std::size_t __n) noexcept + { + using __gnu_cxx::__int_traits; + + if (__n < 2) + return __n; + const unsigned __lz =3D 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 =3D true_type; + + _Power2_rehash_policy(float __z =3D 1.0) noexcept + : _M_max_load_factor(__z), _M_next_resize(0) { } + + float + max_load_factor() const noexcept + { return _M_max_load_factor; } + + + + std::size_t + _M_next_bkt(std::size_t __n) noexcept + { + if (__n =3D=3D 0) + + + + return 1; + + const auto __max_width =3D std::min(sizeof(size_t), 8); + const auto __max_bkt =3D size_t(1) << (__max_width * 8 - 1); + std::size_t __res =3D __clp2(__n); + + if (__res =3D=3D 0) + __res =3D __max_bkt; + else if (__res =3D=3D 1) + + + + __res =3D 2; + + if (__res =3D=3D __max_bkt) + + + + _M_next_resize =3D size_t(-1); + else + _M_next_resize + =3D __builtin_floor(__res * (double)_M_max_load_factor); + + return __res; + } + + + std::size_t + _M_bkt_for_elements(std::size_t __n) const noexcept + { return __builtin_ceil(__n / (double)_M_max_load_factor); } + + + + + + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) noexcept + { + if (__n_elt + __n_ins > _M_next_resize) + { + + + + double __min_bkts + =3D std::max(__n_elt + __n_ins, _M_next_resize ? 0 : 11) + / (double)_M_max_load_factor; + if (__min_bkts >=3D __n_bkt) + return { true, + _M_next_bkt(std::max(__builtin_floor(__min_bkts) + 1, + __n_bkt * _S_growth_factor)) }; + + _M_next_resize + =3D __builtin_floor(__n_bkt * (double)_M_max_load_factor); + return { false, 0 }; + } + else + return { false, 0 }; + } + + typedef std::size_t _State; + + _State + _M_state() const noexcept + { return _M_next_resize; } + + void + _M_reset() noexcept + { _M_next_resize =3D 0; } + + void + _M_reset(_State __state) noexcept + { _M_next_resize =3D __state; } + + static const std::size_t _S_growth_factor =3D 2; + + float _M_max_load_factor; + std::size_t _M_next_resize; + }; +# 732 "/usr/include/c++/13/bits/hashtable_policy.h" 3 + template + struct _Map_base { }; + + + template + struct _Map_base<_Key, pair, _Alloc, _Select1st, _Eq= ual, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + { + using mapped_type =3D _Val; + }; + + + template + struct _Map_base<_Key, pair, _Alloc, _Select1st, _Eq= ual, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> + { + private: + using __hashtable_base =3D _Hashtable_base<_Key, pair, + _Select1st, _Equal, _Hash, + _RangeHash, _Unused, + _Traits>; + + using __hashtable =3D _Hashtable<_Key, pair, _Allo= c, + _Select1st, _Equal, _Hash, _RangeHash, + _Unused, _RehashPolicy, _Traits>; + + using __hash_code =3D typename __hashtable_base::__hash_code; + + public: + using key_type =3D typename __hashtable_base::key_type; + using mapped_type =3D _Val; + + mapped_type& + operator[](const key_type& __k); + + mapped_type& + operator[](key_type&& __k); + + + + mapped_type& + at(const key_type& __k) + { + auto __ite =3D 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 =3D 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 =3D static_cast<__hashtable*>(this); + __hash_code __code =3D __h->_M_hash_code(__k); + std::size_t __bkt =3D __h->_M_bucket_index(__code); + if (auto __node =3D __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 + =3D __h->_M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node =3D 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 =3D static_cast<__hashtable*>(this); + __hash_code __code =3D __h->_M_hash_code(__k); + std::size_t __bkt =3D __h->_M_bucket_index(__code); + if (auto __node =3D __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 + =3D __h->_M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node =3D 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 + struct _Insert_base + { + protected: + using __hashtable_base =3D _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _Hash, _RangeHash, + _Unused, _Traits>; + + using __hashtable =3D _Hashtable<_Key, _Value, _Alloc, _ExtractKey, = _Equal, + _Hash, _RangeHash, + _Unused, _RehashPolicy, _Traits>; + + using __hash_cached =3D typename _Traits::__hash_cached; + using __constant_iterators =3D typename _Traits::__constant_iterator= s; + + using __hashtable_alloc =3D _Hashtable_alloc< + __alloc_rebind<_Alloc, _Hash_node<_Value, + __hash_cached::value>>>; + + using value_type =3D typename __hashtable_base::value_type; + using size_type =3D typename __hashtable_base::size_type; + + using __unique_keys =3D typename _Traits::__unique_keys; + using __node_alloc_type =3D typename __hashtable_alloc::__node_alloc= _type; + using __node_gen_type =3D _AllocNode<__node_alloc_type>; + + __hashtable& + _M_conjure_hashtable() + { return *(static_cast<__hashtable*>(this)); } + + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&, true_type __uks); + + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&, false_type __uks); + + public: + using iterator =3D _Node_iterator<_Value, __constant_iterators::valu= e, + __hash_cached::value>; + + using const_iterator =3D _Node_const_iterator<_Value, + __constant_iterators::value, + __hash_cached::value>; + + using __ireturn_type =3D __conditional_t<__unique_keys::value, + std::pair, + iterator>; + + __ireturn_type + insert(const value_type& __v) + { + __hashtable& __h =3D _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__v, __node_gen, __unique_keys{}); + } + + iterator + insert(const_iterator __hint, const value_type& __v) + { + __hashtable& __h =3D _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, __v, __node_gen, __unique_keys{}); + } + + template + std::pair + try_emplace(const_iterator, _KType&& __k, _Args&&... __args) + { + __hashtable& __h =3D _M_conjure_hashtable(); + auto __code =3D __h._M_hash_code(__k); + std::size_t __bkt =3D __h._M_bucket_index(__code); + if (auto __node =3D __h._M_find_node(__bkt, __k, __code)) + return { iterator(__node), false }; + + typename __hashtable::_Scoped_node __node { + &__h, + std::piecewise_construct, + std::forward_as_tuple(std::forward<_KType>(__k)), + std::forward_as_tuple(std::forward<_Args>(__args)...) + }; + auto __it + =3D __h._M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node =3D nullptr; + return { __it, true }; + } + + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __hashtable& __h =3D _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return _M_insert_range(__first, __last, __node_gen, __unique_keys{}); + } + }; + + template + template + void + _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>:: + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen, true_type __uks) + { + __hashtable& __h =3D _M_conjure_hashtable(); + for (; __first !=3D __last; ++__first) + __h._M_insert(*__first, __node_gen, __uks); + } + + template + template + void + _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>:: + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen, false_type __uks) + { + using __rehash_type =3D typename __hashtable::__rehash_type; + using __rehash_state =3D typename __hashtable::__rehash_state; + using pair_type =3D std::pair; + + size_type __n_elt =3D __detail::__distance_fw(__first, __last); + if (__n_elt =3D=3D 0) + return; + + __hashtable& __h =3D _M_conjure_hashtable(); + __rehash_type& __rehash =3D __h._M_rehash_policy; + const __rehash_state& __saved_state =3D __rehash._M_state(); + pair_type __do_rehash =3D __rehash._M_need_rehash(__h._M_bucket_count, + __h._M_element_count, + __n_elt); + + if (__do_rehash.first) + __h._M_rehash(__do_rehash.second, __saved_state); + + for (; __first !=3D __last; ++__first) + __h._M_insert(*__first, __node_gen, __uks); + } + + + + + + + + template + struct _Insert; + + + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits, true> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> + { + using __base_type =3D _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using value_type =3D typename __base_type::value_type; + using iterator =3D typename __base_type::iterator; + using const_iterator =3D typename __base_type::const_iterator; + using __ireturn_type =3D typename __base_type::__ireturn_type; + + using __unique_keys =3D typename __base_type::__unique_keys; + using __hashtable =3D typename __base_type::__hashtable; + using __node_gen_type =3D typename __base_type::__node_gen_type; + + using __base_type::insert; + + __ireturn_type + insert(value_type&& __v) + { + __hashtable& __h =3D this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys{}); + } + + iterator + insert(const_iterator __hint, value_type&& __v) + { + __hashtable& __h =3D this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys{}); + } + }; + + + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> + { + using __base_type =3D _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + using value_type =3D typename __base_type::value_type; + using iterator =3D typename __base_type::iterator; + using const_iterator =3D typename __base_type::const_iterator; + + using __unique_keys =3D typename __base_type::__unique_keys; + using __hashtable =3D typename __base_type::__hashtable; + using __ireturn_type =3D typename __base_type::__ireturn_type; + + using __base_type::insert; + + template + using __is_cons =3D std::is_constructible; + + template + using _IFcons =3D std::enable_if<__is_cons<_Pair>::value>; + + template + using _IFconsp =3D typename _IFcons<_Pair>::type; + + template> + __ireturn_type + insert(_Pair&& __v) + { + __hashtable& __h =3D this->_M_conjure_hashtable(); + return __h._M_emplace(__unique_keys{}, std::forward<_Pair>(__v)); + } + + template> + iterator + insert(const_iterator __hint, _Pair&& __v) + { + __hashtable& __h =3D this->_M_conjure_hashtable(); + return __h._M_emplace(__hint, __unique_keys{}, + std::forward<_Pair>(__v)); + } + }; + + template + using __has_load_factor =3D 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 =3D _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + public: + float + max_load_factor() const noexcept + { + const __hashtable* __this =3D static_cast(this); + return __this->__rehash_policy().max_load_factor(); + } + + void + max_load_factor(float __z) + { + __hashtable* __this =3D static_cast<__hashtable*>(this); + __this->__rehash_policy(_RehashPolicy(__z)); + } + + void + reserve(std::size_t __n) + { + __hashtable* __this =3D static_cast<__hashtable*>(this); + __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n)); + } + }; + + + + + + + + template + struct _Hashtable_ebo_helper; + + + template + struct _Hashtable_ebo_helper<_Nm, _Tp, true> + : private _Tp + { + _Hashtable_ebo_helper() noexcept(noexcept(_Tp())) : _Tp() { } + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _Tp(std::forward<_OtherTp>(__tp)) + { } + + const _Tp& _M_cget() const { return static_cast(*this); } + _Tp& _M_get() { return static_cast<_Tp&>(*this); } + }; + + + template + struct _Hashtable_ebo_helper<_Nm, _Tp, false> + { + _Hashtable_ebo_helper() =3D default; + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _M_tp(std::forward<_OtherTp>(__tp)) + { } + + const _Tp& _M_cget() const { return _M_tp; } + _Tp& _M_get() { return _M_tp; } + + private: + _Tp _M_tp{}; + }; + + + + + + + + template + struct _Local_iterator_base; +# 1272 "/usr/include/c++/13/bits/hashtable_policy.h" 3 + template + struct _Hash_code_base + : private _Hashtable_ebo_helper<1, _Hash> + { + private: + using __ebo_hash =3D _Hashtable_ebo_helper<1, _Hash>; + + + friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>; + + public: + typedef _Hash hasher; + + hasher + hash_function() const + { return _M_hash(); } + + protected: + typedef std::size_t __hash_code; + + + + _Hash_code_base() =3D default; + + _Hash_code_base(const _Hash& __hash) : __ebo_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()(__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()(__k); + } + + __hash_code + _M_hash_code(const _Hash&, + const _Hash_node_value<_Value, true>& __n) const + { return __n._M_hash_code; } + + + + template + __hash_code + _M_hash_code(const _H2&, + const _Hash_node_value<_Value, __cache_hash_code>& __n) const + { return _M_hash_code(_ExtractKey{}(__n._M_v())); } + + __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; } + + std::size_t + _M_bucket_index(__hash_code __c, std::size_t __bkt_count) const + { return _RangeHash{}(__c, __bkt_count); } + + std::size_t + _M_bucket_index(const _Hash_node_value<_Value, false>& __n, + std::size_t __bkt_count) const + noexcept( noexcept(declval()(declval())) + && noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { + return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())), + __bkt_count); + } + + std::size_t + _M_bucket_index(const _Hash_node_value<_Value, true>& __n, + std::size_t __bkt_count) const + noexcept( noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { return _RangeHash{}(__n._M_hash_code, __bkt_count); } + + void + _M_store_code(_Hash_node_code_cache&, __hash_code) const + { } + + void + _M_copy_code(_Hash_node_code_cache&, + const _Hash_node_code_cache&) const + { } + + void + _M_store_code(_Hash_node_code_cache& __n, __hash_code __c) con= st + { __n._M_hash_code =3D __c; } + + void + _M_copy_code(_Hash_node_code_cache& __to, + const _Hash_node_code_cache& __from) const + { __to._M_hash_code =3D __from._M_hash_code; } + + void + _M_swap(_Hash_code_base& __x) + { std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); } + + const _Hash& + _M_hash() const { return __ebo_hash::_M_cget(); } + }; + + + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, true> + : public _Node_iterator_base<_Value, true> + { + protected: + using __base_node_iter =3D _Node_iterator_base<_Value, true>; + using __hash_code_base =3D _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, true>; + + _Local_iterator_base() =3D default; + _Local_iterator_base(const __hash_code_base&, + _Hash_node<_Value, true>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_cou= nt) + { } + + void + _M_incr() + { + __base_node_iter::_M_incr(); + if (this->_M_cur) + { + std::size_t __bkt + =3D _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count); + if (__bkt !=3D _M_bucket) + this->_M_cur =3D nullptr; + } + } + + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + public: + std::size_t + _M_get_bucket() const { return _M_bucket; } + }; + + + + + + template::value> + struct _Hash_code_storage + { + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + + _Tp* + _M_h() { return _M_storage._M_ptr(); } + + const _Tp* + _M_h() const { return _M_storage._M_ptr(); } + }; + + + template + struct _Hash_code_storage<_Tp, true> + { + static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); + + + + _Tp* + _M_h() { return reinterpret_cast<_Tp*>(this); } + + const _Tp* + _M_h() const { return reinterpret_cast(this); } + }; + + template + using __hash_code_for_local_iter + =3D _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>>; + + + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false> + : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _Hash, _RangeH= ash, + _Unused> + , _Node_iterator_base<_Value, false> + { + protected: + using __hash_code_base =3D _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>; + using __node_iter_base =3D _Node_iterator_base<_Value, false>; + + _Local_iterator_base() : _M_bucket_count(-1) { } + + _Local_iterator_base(const __hash_code_base& __base, + _Hash_node<_Value, false>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_cou= nt) + { _M_init(__base); } + + ~_Local_iterator_base() + { + if (_M_bucket_count !=3D 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 !=3D size_t(-1)) + _M_init(*__iter._M_h()); + } + + _Local_iterator_base& + operator=3D(const _Local_iterator_base& __iter) + { + if (_M_bucket_count !=3D -1) + _M_destroy(); + this->_M_cur =3D __iter._M_cur; + _M_bucket =3D __iter._M_bucket; + _M_bucket_count =3D __iter._M_bucket_count; + if (_M_bucket_count !=3D -1) + _M_init(*__iter._M_h()); + return *this; + } + + void + _M_incr() + { + __node_iter_base::_M_incr(); + if (this->_M_cur) + { + std::size_t __bkt =3D this->_M_h()->_M_bucket_index(*this->_M_cur, + _M_bucket_count); + if (__bkt !=3D _M_bucket) + this->_M_cur =3D nullptr; + } + } + + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + void + _M_init(const __hash_code_base& __base) + { ::new(this->_M_h()) __hash_code_base(__base); } + + void + _M_destroy() { this->_M_h()->~__hash_code_base(); } + + public: + std::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 =3D _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache>; + using __hash_code_base =3D typename __base_type::__hash_code_base; + + public: + using value_type =3D _Value; + using pointer =3D __conditional_t<__constant_iterators, + const value_type*, value_type*>; + using reference =3D __conditional_t<__constant_iterators, + const value_type&, value_type&>; + using difference_type =3D ptrdiff_t; + using iterator_category =3D forward_iterator_tag; + + _Local_iterator() =3D default; + + _Local_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __n, + std::size_t __bkt, std::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 =3D _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache>; + using __hash_code_base =3D typename __base_type::__hash_code_base; + + public: + typedef _Value value_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Local_const_iterator() =3D default; + + _Local_const_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __n, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base, __n, __bkt, __bkt_count) + { } + + _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKe= y, + _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; + } + }; +# 1664 "/usr/include/c++/13/bits/hashtable_policy.h" 3 + template + struct _Hashtable_base + : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, + _Unused, _Traits::__hash_cached::value>, + private _Hashtable_ebo_helper<0, _Equal> + { + public: + typedef _Key key_type; + typedef _Value value_type; + typedef _Equal key_equal; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + using __traits_type =3D _Traits; + using __hash_cached =3D typename __traits_type::__hash_cached; + + using __hash_code_base =3D _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, + __hash_cached::value>; + + using __hash_code =3D typename __hash_code_base::__hash_code; + + private: + using _EqualEBO =3D _Hashtable_ebo_helper<0, _Equal>; + + static bool + _S_equals(__hash_code, const _Hash_node_code_cache&) + { return true; } + + static bool + _S_node_equals(const _Hash_node_code_cache&, + const _Hash_node_code_cache&) + { return true; } + + static bool + _S_equals(__hash_code __c, const _Hash_node_code_cache& __n) + { return __c =3D=3D __n._M_hash_code; } + + static bool + _S_node_equals(const _Hash_node_code_cache& __lhn, + const _Hash_node_code_cache& __rhn) + { return __lhn._M_hash_code =3D=3D __rhn._M_hash_code; } + + protected: + _Hashtable_base() =3D default; + + _Hashtable_base(const _Hash& __hash, const _Equal& __eq) + : __hash_code_base(__hash), _EqualEBO(__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 two arguments of " + "key type"); + return _M_eq()(__k, _ExtractKey{}(__n._M_v())); + } + + bool + _M_equals(const _Key& __k, __hash_code __c, + const _Hash_node_value<_Value, __hash_cached::value>& __n) const + { return _S_equals(__c, __n) && _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 + { return _S_equals(__c, __n) && _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 + { + return _S_node_equals(__lhn, __rhn) + && _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn); + } + + void + _M_swap(_Hashtable_base& __x) + { + __hash_code_base::_M_swap(__x); + std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get()); + } + + const _Equal& + _M_eq() const { return _EqualEBO::_M_cget(); } + }; +# 1780 "/usr/include/c++/13/bits/hashtable_policy.h" 3 + template + struct _Equality; + + + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> + { + using __hashtable =3D _Hashtable<_Key, _Value, _Alloc, _ExtractKey, = _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: + _M_equal(const __hashtable& __other) const + { + using __node_type =3D typename __hashtable::__node_type; + const __hashtable* __this =3D static_cast(this); + if (__this->size() !=3D __other.size()) + return false; + + for (auto __itx =3D __this->begin(); __itx !=3D __this->end(); ++__i= tx) + { + std::size_t __ybkt =3D __other._M_bucket_index(*__itx._M_cur); + auto __prev_n =3D __other._M_buckets[__ybkt]; + if (!__prev_n) + return false; + + for (__node_type* __n =3D static_cast<__node_type*>(__prev_n->_M_nxt);; + __n =3D __n->_M_next()) + { + if (__n->_M_v() =3D=3D *__itx) + break; + + if (!__n->_M_nxt + || __other._M_bucket_index(*__n->_M_next()) !=3D __ybkt) + return false; + } + } + + return true; + } + + + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + { + using __hashtable =3D _Hashtable<_Key, _Value, _Alloc, _ExtractKey, = _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>:: + _M_equal(const __hashtable& __other) const + { + using __node_type =3D typename __hashtable::__node_type; + const __hashtable* __this =3D static_cast(this); + if (__this->size() !=3D __other.size()) + return false; + + for (auto __itx =3D __this->begin(); __itx !=3D __this->end();) + { + std::size_t __x_count =3D 1; + auto __itx_end =3D __itx; + for (++__itx_end; __itx_end !=3D __this->end() + && __this->key_eq()(_ExtractKey{}(*__itx), + _ExtractKey{}(*__itx_end)); + ++__itx_end) + ++__x_count; + + std::size_t __ybkt =3D __other._M_bucket_index(*__itx._M_cur); + auto __y_prev_n =3D __other._M_buckets[__ybkt]; + if (!__y_prev_n) + return false; + + __node_type* __y_n =3D static_cast<__node_type*>(__y_prev_n->_M_nxt); + for (;;) + { + if (__this->key_eq()(_ExtractKey{}(__y_n->_M_v()), + _ExtractKey{}(*__itx))) + break; + + auto __y_ref_n =3D __y_n; + for (__y_n =3D __y_n->_M_next(); __y_n; __y_n =3D __y_n->_M_next()) + if (!__other._M_node_equals(*__y_ref_n, *__y_n)) + break; + + if (!__y_n || __other._M_bucket_index(*__y_n) !=3D __ybkt) + return false; + } + + typename __hashtable::const_iterator __ity(__y_n); + for (auto __ity_end =3D __ity; __ity_end !=3D __other.end(); ++__ity_en= d) + if (--__x_count =3D=3D 0) + break; + + if (__x_count !=3D 0) + return false; + + if (!std::is_permutation(__itx, __itx_end, __ity)) + return false; + + __itx =3D __itx_end; + } + return true; + } + + + + + + template + struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> + { + private: + using __ebo_node_alloc =3D _Hashtable_ebo_helper<0, _NodeAlloc>; + + template + struct __get_value_type; + template + struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>> + { using type =3D _Val; }; + + public: + using __node_type =3D typename _NodeAlloc::value_type; + using __node_alloc_type =3D _NodeAlloc; + + using __node_alloc_traits =3D __gnu_cxx::__alloc_traits<__node_alloc= _type>; + + using __value_alloc_traits =3D typename __node_alloc_traits::template + rebind_traits::type>; + + using __node_ptr =3D __node_type*; + using __node_base =3D _Hash_node_base; + using __node_base_ptr =3D __node_base*; + using __buckets_alloc_type =3D + __alloc_rebind<__node_alloc_type, __node_base_ptr>; + using __buckets_alloc_traits =3D std::allocator_traits<__buckets_all= oc_type>; + using __buckets_ptr =3D __node_base_ptr*; + + _Hashtable_alloc() =3D default; + _Hashtable_alloc(const _Hashtable_alloc&) =3D default; + _Hashtable_alloc(_Hashtable_alloc&&) =3D default; + + template + _Hashtable_alloc(_Alloc&& __a) + : __ebo_node_alloc(std::forward<_Alloc>(__a)) + { } + + __node_alloc_type& + _M_node_allocator() + { return __ebo_node_alloc::_M_get(); } + + const __node_alloc_type& + _M_node_allocator() const + { return __ebo_node_alloc::_M_cget(); } + + + 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(std::size_t __bkt_count); + + void + _M_deallocate_buckets(__buckets_ptr, std::size_t __bkt_count); + }; + + + + template + template + auto + _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) + -> __node_ptr + { + auto __nptr =3D __node_alloc_traits::allocate(_M_node_allocator(), 1); + __node_ptr __n =3D std::__to_address(__nptr); + if (true) + { + ::new ((void*)__n) __node_type; + __node_alloc_traits::construct(_M_node_allocator(), + __n->_M_valptr(), + std::forward<_Args>(__args)...); + return __n; + } + if (false) + { + __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); + ; + } + } + + 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) + { + typedef typename __node_alloc_traits::pointer _Ptr; + auto __ptr =3D 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 =3D __n; + __n =3D __n->_M_next(); + _M_deallocate_node(__tmp); + } + } + + template + auto + _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_co= unt) + -> __buckets_ptr + { + __buckets_alloc_type __alloc(_M_node_allocator()); + + auto __ptr =3D __buckets_alloc_traits::allocate(__alloc, __bkt_count= ); + __buckets_ptr __p =3D 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, + std::size_t __bkt_count) + { + typedef typename __buckets_alloc_traits::pointer _Ptr; + auto __ptr =3D std::pointer_traits<_Ptr>::pointer_to(*__bkts); + __buckets_alloc_type __alloc(_M_node_allocator()); + __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count); + } + + +} + + +} +# 36 "/usr/include/c++/13/bits/hashtable.h" 2 3 + + + +# 1 "/usr/include/c++/13/bits/node_handle.h" 1 3 +# 34 "/usr/include/c++/13/bits/node_handle.h" 3 +=20=20=20=20=20=20=20 +# 35 "/usr/include/c++/13/bits/node_handle.h" 3 +# 43 "/usr/include/c++/13/bits/node_handle.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/include/c++/13/bits/node_handle.h" 3 + template + class _Node_handle_common + { + using _AllocTraits =3D allocator_traits<_NodeAlloc>; + + public: + using allocator_type =3D __alloc_rebind<_NodeAlloc, _Val>; + + allocator_type + get_allocator() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __built= in_unreachable(); } while (false); + return allocator_type(_M_alloc._M_alloc); + } + + explicit operator bool() const noexcept { return _M_ptr !=3D nullptr= ; } + + [[nodiscard]] bool empty() const noexcept { return _M_ptr =3D=3D nul= lptr; } + + + 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=3D(_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 =3D __nh._M_alloc.release(); + _M_ptr =3D __nh._M_ptr; + __nh._M_ptr =3D 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 !=3D nullptr)) __b= uiltin_unreachable(); } 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 =3D __nh._M_ptr; + __nh._M_ptr =3D nullptr; + } + + + + + void + _M_reset() noexcept + { + _NodeAlloc __alloc =3D _M_alloc.release(); + _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr()); + _AllocTraits::deallocate(__alloc, _M_ptr, 1); + _M_ptr =3D nullptr; + } + + protected: + typename _AllocTraits::pointer _M_ptr; + + private: + + + union _Optional_alloc + { + _Optional_alloc() { } + ~_Optional_alloc() { } + + _Optional_alloc(_Optional_alloc&&) =3D delete; + _Optional_alloc& operator=3D(_Optional_alloc&&) =3D delete; + + _Optional_alloc(const _NodeAlloc& __alloc) noexcept + : _M_alloc(__alloc) + { } + + + void + operator=3D(_NodeAlloc&& __alloc) noexcept + { + using _ATr =3D _AllocTraits; + if constexpr (_ATr::propagate_on_container_move_assignment::value) + _M_alloc =3D std::move(__alloc); + else if constexpr (!_AllocTraits::is_always_equal::value) + do { if (std::__is_constant_evaluated() && !bool(_M_alloc =3D=3D __al= loc)) __builtin_unreachable(); } 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 =3D=3D __ot= her._M_alloc)) __builtin_unreachable(); } while (false); + } + + + _NodeAlloc& operator*() noexcept { return _M_alloc; } + + + _NodeAlloc release() noexcept + { + _NodeAlloc __tmp =3D std::move(_M_alloc); + _M_alloc.~_NodeAlloc(); + return __tmp; + } + + struct _Empty { }; + + [[__no_unique_address__]] _Empty _M_empty; + [[__no_unique_address__]] _NodeAlloc _M_alloc; + }; + + [[__no_unique_address__]] _Optional_alloc _M_alloc; + + template + friend class _Rb_tree; + + + }; + + + template + class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> + { + public: + constexpr _Node_handle() noexcept =3D default; + ~_Node_handle() =3D default; + _Node_handle(_Node_handle&&) noexcept =3D default; + + _Node_handle& + operator=3D(_Node_handle&&) noexcept =3D default; + + using key_type =3D _Key; + using mapped_type =3D typename _Value::second_type; + + key_type& + key() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __built= in_unreachable(); } while (false); + return *_M_pkey; + } + + mapped_type& + mapped() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __built= in_unreachable(); } 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 =3D allocator_traits<_NodeAlloc>; + + _Node_handle(typename _AllocTraits::pointer __ptr, + const _NodeAlloc& __alloc) + : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) + { + if (__ptr) + { + auto& __key =3D const_cast<_Key&>(__ptr->_M_valptr()->first); + _M_pkey =3D _S_pointer_to(__key); + _M_pmapped =3D _S_pointer_to(__ptr->_M_valptr()->second); + } + else + { + _M_pkey =3D nullptr; + _M_pmapped =3D nullptr; + } + } + + template + using __pointer + =3D __ptr_rebind>; + + __pointer<_Key> _M_pkey =3D nullptr; + __pointer _M_pmapped =3D 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 =3D default; + ~_Node_handle() =3D default; + _Node_handle(_Node_handle&&) noexcept =3D default; + + _Node_handle& + operator=3D(_Node_handle&&) noexcept =3D default; + + using value_type =3D _Value; + + value_type& + value() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __built= in_unreachable(); } 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 =3D 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 =3D _Iterator(); + bool inserted =3D false; + _NodeHandle node; + }; + + + + +} +# 40 "/usr/include/c++/13/bits/hashtable.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + using __cache_default + =3D __not_<__and_< + __is_fast_hash<_Hash>, + + __is_nothrow_invocable>>; + + + + + template + using _Hashtable_enable_default_ctor + =3D _Enable_default_constructor<__and_, + is_default_constructible<_Hash>, + is_default_constructible<_Allocator>>{}, + __detail::_Hash_node_base>; +# 177 "/usr/include/c++/13/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::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Eq= ual, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + public __detail::_Equality<_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>::val= ue, + "unordered container must have a non-const, non-volatile value_type"); + + + + + + using __traits_type =3D _Traits; + using __hash_cached =3D typename __traits_type::__hash_cached; + using __constant_iterators =3D typename __traits_type::__constant_it= erators; + using __node_type =3D __detail::_Hash_node<_Value, __hash_cached::va= lue>; + using __node_alloc_type =3D __alloc_rebind<_Alloc, __node_type>; + + using __hashtable_alloc =3D __detail::_Hashtable_alloc<__node_alloc_= type>; + + using __node_value_type =3D + __detail::_Hash_node_value<_Value, __hash_cached::value>; + using __node_ptr =3D typename __hashtable_alloc::__node_ptr; + using __value_alloc_traits =3D + typename __hashtable_alloc::__value_alloc_traits; + using __node_alloc_traits =3D + typename __hashtable_alloc::__node_alloc_traits; + using __node_base =3D typename __hashtable_alloc::__node_base; + using __node_base_ptr =3D typename __hashtable_alloc::__node_base_pt= r; + using __buckets_ptr =3D typename __hashtable_alloc::__buckets_ptr; + + using __insert_base =3D __detail::_Insert<_Key, _Value, _Alloc, _Ext= ractKey, + _Equal, _Hash, + _RangeHash, _Unused, + _RehashPolicy, _Traits>; + using __enable_default_ctor + =3D _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>; + + 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 =3D typename __insert_base::iterator; + + using const_iterator =3D typename __insert_base::const_iterator; + + using local_iterator =3D __detail::_Local_iterator; + + using const_local_iterator =3D __detail::_Local_const_iterator< + key_type, _Value, + _ExtractKey, _Hash, _RangeHash, _Unused, + __constant_iterators::value, __hash_cached::value>; + + private: + using __rehash_type =3D _RehashPolicy; + using __rehash_state =3D typename __rehash_type::_State; + + using __unique_keys =3D typename __traits_type::__unique_keys; + + using __hashtable_base =3D __detail:: + _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, _Traits>; + + using __hash_code_base =3D typename __hashtable_base::__hash_code_ba= se; + using __hash_code =3D typename __hashtable_base::__hash_code; + using __ireturn_type =3D typename __insert_base::__ireturn_type; + + using __map_base =3D __detail::_Map_base<_Key, _Value, _Alloc, _Extr= actKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __rehash_base =3D __detail::_Rehash_base<_Key, _Value, _Alloc, + _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __eq_base =3D __detail::_Equality<_Key, _Value, _Alloc, _Extra= ctKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __reuse_or_alloc_node_gen_t =3D + __detail::_ReuseOrAllocNode<__node_alloc_type>; + using __alloc_node_gen_t =3D + __detail::_AllocNode<__node_alloc_type>; + using __node_builder_t =3D + __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&) =3D delete; + _Scoped_node& operator=3D(const _Scoped_node&) =3D delete; + + __hashtable_alloc* _M_h; + __node_ptr _M_node; + }; + + template + static constexpr + __conditional_t::value, + const value_type&, value_type&&> + __fwd_value_for(value_type& __val) noexcept + { return std::move(__val); } + + + + + + 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; + + template + friend struct __detail::_Insert_base; + + template + friend struct __detail::_Insert; + + template + friend struct __detail::_Equality; + + public: + using size_type =3D typename __hashtable_base::size_type; + using difference_type =3D typename __hashtable_base::difference_type; + + + using node_type =3D _Node_handle<_Key, _Value, __node_alloc_type>; + using insert_return_type =3D _Node_insert_return; + + + private: + __buckets_ptr _M_buckets =3D &_M_single_bucket; + size_type _M_bucket_count =3D 1; + __node_base _M_before_begin; + size_type _M_element_count =3D 0; + _RehashPolicy _M_rehash_policy; + + + + + + + + __node_base_ptr _M_single_bucket =3D nullptr; + + void + _M_update_bbegin() + { + if (_M_begin()) + _M_buckets[_M_bucket_index(*_M_begin())] =3D &_M_before_begin; + } + + void + _M_update_bbegin(__node_ptr __n) + { + _M_before_begin._M_nxt =3D __n; + _M_update_bbegin(); + } + + bool + _M_uses_single_bucket(__buckets_ptr __bkts) const + { return __builtin_expect(__bkts =3D=3D &_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 =3D=3D 1, false)) + { + _M_single_bucket =3D 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_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&&, const _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() =3D default; + + _Hashtable(const _Hashtable&); + + _Hashtable(const _Hashtable&, const allocator_type&); + + explicit + _Hashtable(size_type __bkt_count_hint, + const _Hash& __hf =3D _Hash(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D 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 =3D 0, + const _Hash& __hf =3D _Hash(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a, + __unique_keys{}) + { } + + _Hashtable(initializer_list __l, + size_type __bkt_count_hint =3D 0, + const _Hash& __hf =3D _Hash(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, + __hf, __eql, __a, __unique_keys{}) + { } + + _Hashtable& + operator=3D(const _Hashtable& __ht); + + _Hashtable& + operator=3D(_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 =3D + __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; + } + + _Hashtable& + operator=3D(initializer_list __l) + { + __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); + _M_before_begin._M_nxt =3D nullptr; + clear(); + + + auto __l_bkt_count =3D _M_rehash_policy._M_bkt_for_elements(__l.size()); + + + if (_M_bucket_count < __l_bkt_count) + rehash(__l_bkt_count); + + this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{}); + return *this; + } + + ~_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() =3D=3D 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 =3D __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; +# 789 "/usr/include/c++/13/bits/hashtable.h" 3 + 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); } + + __node_base_ptr + _M_find_before_node(const key_type&); + + + + __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; + + __node_ptr + _M_find_node(size_type __bkt, const key_type& __key, + __hash_code __c) const + { + __node_base_ptr __before_n =3D _M_find_before_node(__bkt, __key, __c); + if (__before_n) + 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 + { + auto __before_n =3D _M_find_before_node_tr(__bkt, __key, __c); + if (__before_n) + return static_cast<__node_ptr>(__before_n->_M_nxt); + return nullptr; + } + + + void + _M_insert_bucket_begin(size_type, __node_ptr); + + + void + _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n, + size_type __next_bkt); + + + __node_base_ptr + _M_get_previous_node(size_type __bkt, __node_ptr __n); + + pair + _M_compute_hash_code(const_iterator __hint, const key_type& __k) con= st; + + + + + iterator + _M_insert_unique_node(size_type __bkt, __hash_code, + __node_ptr __n, size_type __n_elt =3D 1); + + + + iterator + _M_insert_multi_node(__node_ptr __hint, + __hash_code __code, __node_ptr __n); + + template + std::pair + _M_emplace(true_type __uks, _Args&&... __args); + + template + iterator + _M_emplace(false_type __uks, _Args&&... __args) + { return _M_emplace(cend(), __uks, std::forward<_Args>(__args)...); } + + + template + iterator + _M_emplace(const_iterator, true_type __uks, _Args&&... __args) + { return _M_emplace(__uks, std::forward<_Args>(__args)...).first; } + + template + iterator + _M_emplace(const_iterator, false_type __uks, _Args&&... __args); + + template + std::pair + _M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&); + + template + static __conditional_t< + __and_<__is_nothrow_invocable<_Hash&, const key_type&>, + __not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value, + key_type, _Kt&&> + _S_forward_key(_Kt&& __k) + { return std::forward<_Kt>(__k); } + + static const key_type& + _S_forward_key(const key_type& __k) + { return __k; } + + static key_type&& + _S_forward_key(key_type&& __k) + { return std::move(__k); } + + template + std::pair + _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen) + { + return _M_insert_unique( + _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))), + std::forward<_Arg>(__arg), __node_gen); + } + + template + std::pair + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + true_type ) + { + using __to_value + =3D __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert_unique_aux( + __to_value{}(std::forward<_Arg>(__arg)), __node_gen); + } + + template + iterator + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + false_type __uks) + { + using __to_value + =3D __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert(cend(), + __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks); + } + + + template + iterator + _M_insert(const_iterator, _Arg&& __arg, + const _NodeGenerator& __node_gen, true_type __uks) + { + return + _M_insert(std::forward<_Arg>(__arg), __node_gen, __uks).first; + } + + + template + iterator + _M_insert(const_iterator, _Arg&&, + const _NodeGenerator&, false_type __uks); + + size_type + _M_erase(true_type __uks, const key_type&); + + size_type + _M_erase(false_type __uks, const key_type&); + + iterator + _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n); + + public: + + template + __ireturn_type + emplace(_Args&&... __args) + { return _M_emplace(__unique_keys{}, std::forward<_Args>(__args)...); } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + return _M_emplace(__hint, __unique_keys{}, + std::forward<_Args>(__args)...); + } + + + + + iterator + erase(const_iterator); + + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + size_type + erase(const key_type& __k) + { return _M_erase(__unique_keys{}, __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 =3D end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(get_allocator() =3D= =3D __nh.get_allocator())) __builtin_unreachable(); } while (false); + + const key_type& __k =3D __nh._M_key(); + __hash_code __code =3D this->_M_hash_code(__k); + size_type __bkt =3D _M_bucket_index(__code); + if (__node_ptr __n =3D _M_find_node(__bkt, __k, __code)) + { + __ret.node =3D std::move(__nh); + __ret.position =3D iterator(__n); + __ret.inserted =3D false; + } + else + { + __ret.position + =3D _M_insert_unique_node(__bkt, __code, __nh._M_ptr); + __nh._M_ptr =3D nullptr; + __ret.inserted =3D true; + } + } + 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() =3D=3D _= _nh.get_allocator())) __builtin_unreachable(); } while (false); + + const key_type& __k =3D __nh._M_key(); + auto __code =3D this->_M_hash_code(__k); + auto __ret + =3D _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr); + __nh._M_ptr =3D nullptr; + return __ret; + } + + private: + node_type + _M_extract_node(size_t __bkt, __node_base_ptr __prev_n) + { + __node_ptr __n =3D static_cast<__node_ptr>(__prev_n->_M_nxt); + if (__prev_n =3D=3D _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 =3D _M_bucket_index(*__n->_M_next()); + if (__next_bkt !=3D __bkt) + _M_buckets[__next_bkt] =3D __prev_n; + } + + __prev_n->_M_nxt =3D __n->_M_nxt; + __n->_M_nxt =3D nullptr; + --_M_element_count; + return { __n, this->_M_node_allocator() }; + } + + public: + + node_type + extract(const_iterator __pos) + { + size_t __bkt =3D _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 =3D this->_M_hash_code(__k); + std::size_t __bkt =3D _M_bucket_index(__code); + if (__node_base_ptr __prev_node =3D _M_find_before_node(__bkt, __k, __cod= e)) + __nh =3D _M_extract_node(__bkt, __prev_node); + return __nh; + } + + + 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() =3D=3D= __src.get_allocator())) __builtin_unreachable(); } while (false); + + auto __n_elt =3D __src.size(); + for (auto __i =3D __src.cbegin(), __end =3D __src.cend(); __i !=3D __en= d;) + { + auto __pos =3D __i++; + const key_type& __k =3D _ExtractKey{}(*__pos); + __hash_code __code + =3D this->_M_hash_code(__src.hash_function(), *__pos._M_cur); + size_type __bkt =3D _M_bucket_index(__code); + if (_M_find_node(__bkt, __k, __code) =3D=3D nullptr) + { + auto __nh =3D __src.extract(__pos); + _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt); + __nh._M_ptr =3D nullptr; + __n_elt =3D 1; + } + else if (__n_elt !=3D 1) + --__n_elt; + } + } + + + 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() =3D=3D= __src.get_allocator())) __builtin_unreachable(); } while (false); + + __node_ptr __hint =3D nullptr; + this->reserve(size() + __src.size()); + for (auto __i =3D __src.cbegin(), __end =3D __src.cend(); __i !=3D __en= d;) + { + auto __pos =3D __i++; + __hash_code __code + =3D this->_M_hash_code(__src.hash_function(), *__pos._M_cur); + auto __nh =3D __src.extract(__pos); + __hint =3D _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; + __nh._M_ptr =3D nullptr; + } + } + + + private: + + void _M_rehash_aux(size_type __bkt_count, true_type __uks); + + + void _M_rehash_aux(size_type __bkt_count, false_type __uks); + + + + void _M_rehash(size_type __bkt_count, const __rehash_state& __state); + }; + + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_bucket_begin(size_type __bkt) const + -> __node_ptr + { + __node_base_ptr __n =3D _M_buckets[__bkt]; + return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr; + } + + 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 =3D _M_rehash_policy._M_next_bkt(__bkt_count_hint); + if (__bkt_count > _M_bucket_count) + { + _M_buckets =3D _M_allocate_buckets(__bkt_count); + _M_bucket_count =3D __bkt_count; + } + } + + 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, 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 =3D __detail::__distance_fw(__f, __l); + auto __bkt_count =3D + _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 =3D _M_allocate_buckets(__bkt_count); + _M_bucket_count =3D __bkt_count; + } + + __alloc_node_gen_t __node_gen(*this); + for (; __f !=3D __l; ++__f) + _M_insert(*__f, __node_gen, __uks); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + operator=3D(const _Hashtable& __ht) + -> _Hashtable& + { + if (&__ht =3D=3D this) + return *this; + + if (__node_alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc =3D this->_M_node_allocator(); + auto& __that_alloc =3D __ht._M_node_allocator(); + if (!__node_alloc_traits::_S_always_equal() + && __this_alloc !=3D __that_alloc) + { + + this->_M_deallocate_nodes(_M_begin()); + _M_before_begin._M_nxt =3D nullptr; + _M_deallocate_buckets(); + _M_buckets =3D nullptr; + std::__alloc_on_copy(__this_alloc, __that_alloc); + __hashtable_base::operator=3D(__ht); + _M_bucket_count =3D __ht._M_bucket_count; + _M_element_count =3D __ht._M_element_count; + _M_rehash_policy =3D __ht._M_rehash_policy; + __alloc_node_gen_t __alloc_node_gen(*this); + if (true) + { + _M_assign(__ht, __alloc_node_gen); + } + if (false) + { + + + _M_reset(); + ; + } + 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) + { + __buckets_ptr __former_buckets =3D nullptr; + std::size_t __former_bucket_count =3D _M_bucket_count; + const __rehash_state& __former_state =3D _M_rehash_policy._M_state(); + + if (_M_bucket_count !=3D __ht._M_bucket_count) + { + __former_buckets =3D _M_buckets; + _M_buckets =3D _M_allocate_buckets(__ht._M_bucket_count); + _M_bucket_count =3D __ht._M_bucket_count; + } + else + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + + if (true) + { + __hashtable_base::operator=3D(std::forward<_Ht>(__ht)); + _M_element_count =3D __ht._M_element_count; + _M_rehash_policy =3D __ht._M_rehash_policy; + __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); + _M_before_begin._M_nxt =3D nullptr; + _M_assign(std::forward<_Ht>(__ht), __roan); + if (__former_buckets) + _M_deallocate_buckets(__former_buckets, __former_bucket_count); + } + if (false) + { + if (__former_buckets) + { + + _M_deallocate_buckets(); + _M_rehash_policy._M_reset(__former_state); + _M_buckets =3D __former_buckets; + _M_bucket_count =3D __former_bucket_count; + } + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + ; + } + } + + template + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen) + { + __buckets_ptr __buckets =3D nullptr; + if (!_M_buckets) + _M_buckets =3D __buckets =3D _M_allocate_buckets(_M_bucket_count); + + if (true) + { + if (!__ht._M_before_begin._M_nxt) + return; + + + + __node_ptr __ht_n =3D __ht._M_begin(); + __node_ptr __this_n + =3D __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); + this->_M_copy_code(*__this_n, *__ht_n); + _M_update_bbegin(__this_n); + + + __node_ptr __prev_n =3D __this_n; + for (__ht_n =3D __ht_n->_M_next(); __ht_n; __ht_n =3D __ht_n->_M_next= ()) + { + __this_n =3D __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); + __prev_n->_M_nxt =3D __this_n; + this->_M_copy_code(*__this_n, *__ht_n); + size_type __bkt =3D _M_bucket_index(*__this_n); + if (!_M_buckets[__bkt]) + _M_buckets[__bkt] =3D __prev_n; + __prev_n =3D __this_n; + } + } + if (false) + { + clear(); + if (__buckets) + _M_deallocate_buckets(); + ; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_reset() noexcept + { + _M_rehash_policy._M_reset(); + _M_bucket_count =3D 1; + _M_single_bucket =3D nullptr; + _M_buckets =3D &_M_single_bucket; + _M_before_begin._M_nxt =3D nullptr; + _M_element_count =3D 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) =3D=3D this, false)) + return; + + this->_M_deallocate_nodes(_M_begin()); + _M_deallocate_buckets(); + __hashtable_base::operator=3D(std::move(__ht)); + _M_rehash_policy =3D __ht._M_rehash_policy; + if (!__ht._M_uses_single_bucket()) + _M_buckets =3D __ht._M_buckets; + else + { + _M_buckets =3D &_M_single_bucket; + _M_single_bucket =3D __ht._M_single_bucket; + } + + _M_bucket_count =3D __ht._M_bucket_count; + _M_before_begin._M_nxt =3D __ht._M_before_begin._M_nxt; + _M_element_count =3D __ht._M_element_count; + std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocat= or()); + + + _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() =3D=3D this->_M_node_allocator()) + _M_move_assign(std::move(__ht), true_type{}); + else + { + + _M_assign_elements(std::move(__ht)); + __ht.clear(); + } + } + + template + _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) + { + __alloc_node_gen_t __alloc_node_gen(*this); + _M_assign(__ht, __alloc_node_gen); + } + + 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 =3D &_M_single_bucket; + _M_single_bucket =3D __ht._M_single_bucket; + } + + + _M_update_bbegin(); + + __ht._M_reset(); + } + + template + _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) + { + __alloc_node_gen_t __alloc_node_gen(*this); + _M_assign(__ht, __alloc_node_gen); + } + + 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() =3D=3D this->_M_node_allocator()) + { + if (__ht._M_uses_single_bucket()) + { + _M_buckets =3D &_M_single_bucket; + _M_single_bucket =3D __ht._M_single_bucket; + } + else + _M_buckets =3D __ht._M_buckets; + + + + _M_update_bbegin(__ht._M_begin()); + + __ht._M_reset(); + } + else + { + __alloc_node_gen_t __alloc_gen(*this); + + using _Fwd_Ht =3D __conditional_t< + __move_if_noexcept_cond::value, + const _Hashtable&, _Hashtable&&>; + _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen); + __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"); + + clear(); + _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) + { + + + + this->_M_swap(__x); + + std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocato= r()); + std::swap(_M_rehash_policy, __x._M_rehash_policy); + + + if (this->_M_uses_single_bucket()) + { + if (!__x._M_uses_single_bucket()) + { + _M_buckets =3D __x._M_buckets; + __x._M_buckets =3D &__x._M_single_bucket; + } + } + else if (__x._M_uses_single_bucket()) + { + __x._M_buckets =3D _M_buckets; + _M_buckets =3D &_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 + { + if (size() <=3D __small_size_threshold()) + { + for (auto __it =3D begin(); __it !=3D end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return __it; + return end(); + } + + __hash_code __code =3D this->_M_hash_code(__k); + std::size_t __bkt =3D _M_bucket_index(__code); + return iterator(_M_find_node(__bkt, __k, __code)); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + find(const key_type& __k) const + -> const_iterator + { + if (size() <=3D __small_size_threshold()) + { + for (auto __it =3D begin(); __it !=3D end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return __it; + return end(); + } + + __hash_code __code =3D this->_M_hash_code(__k); + std::size_t __bkt =3D _M_bucket_index(__code); + return const_iterator(_M_find_node(__bkt, __k, __code)); + } +# 1724 "/usr/include/c++/13/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 =3D find(__k); + if (!__it._M_cur) + return 0; + + if (__unique_keys::value) + return 1; + + + + + size_type __result =3D 1; + for (auto __ref =3D __it++; + __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur); + ++__it) + ++__result; + + return __result; + } +# 1785 "/usr/include/c++/13/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 =3D find(__k); + if (!__ite._M_cur) + return { __ite, __ite }; + + auto __beg =3D __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 =3D find(__k); + if (!__ite._M_cur) + return { __ite, __ite }; + + auto __beg =3D __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 }; + } +# 1899 "/usr/include/c++/13/bits/hashtable.h" 3 + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_find_before_node(const key_type& __k) + -> __node_base_ptr + { + __node_base_ptr __prev_p =3D &_M_before_begin; + if (!__prev_p->_M_nxt) + return nullptr; + + for (__node_ptr __p =3D static_cast<__node_ptr>(__prev_p->_M_nxt); + __p !=3D nullptr; + __p =3D __p->_M_next()) + { + if (this->_M_key_equals(__k, *__p)) + return __prev_p; + + __prev_p =3D __p; + } + + return nullptr; + } + + + + 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 =3D _M_buckets[__bkt]; + if (!__prev_p) + return nullptr; + + for (__node_ptr __p =3D static_cast<__node_ptr>(__prev_p->_M_nxt);; + __p =3D __p->_M_next()) + { + if (this->_M_equals(__k, __code, *__p)) + return __prev_p; + + if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) !=3D __bkt) + break; + __prev_p =3D __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 =3D _M_buckets[__bkt]; + if (!__prev_p) + return nullptr; + + for (__node_ptr __p =3D static_cast<__node_ptr>(__prev_p->_M_nxt);; + __p =3D __p->_M_next()) + { + if (this->_M_equals_tr(__k, __code, *__p)) + return __prev_p; + + if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) !=3D __bkt) + break; + __prev_p =3D __p; + } + + return nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_bucket_begin(size_type __bkt, __node_ptr __node) + { + if (_M_buckets[__bkt]) + { + + + __node->_M_nxt =3D _M_buckets[__bkt]->_M_nxt; + _M_buckets[__bkt]->_M_nxt =3D __node; + } + else + { + + + + __node->_M_nxt =3D _M_before_begin._M_nxt; + _M_before_begin._M_nxt =3D __node; + + if (__node->_M_nxt) + + + _M_buckets[_M_bucket_index(*__node->_M_next())] =3D __node; + + _M_buckets[__bkt] =3D &_M_before_begin; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_remove_bucket_begin(size_type __bkt, __node_ptr __next, + size_type __next_bkt) + { + if (!__next || __next_bkt !=3D __bkt) + { + + + if (__next) + _M_buckets[__next_bkt] =3D _M_buckets[__bkt]; + + + if (&_M_before_begin =3D=3D _M_buckets[__bkt]) + _M_before_begin._M_nxt =3D __next; + _M_buckets[__bkt] =3D nullptr; + } + } + + 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 =3D _M_buckets[__bkt]; + while (__prev_n->_M_nxt !=3D __n) + __prev_n =3D __prev_n->_M_nxt; + return __prev_n; + } + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_emplace(true_type , _Args&&... __args) + -> pair + { + + _Scoped_node __node { this, std::forward<_Args>(__args)... }; + const key_type& __k =3D _ExtractKey{}(__node._M_node->_M_v()); + if (size() <=3D __small_size_threshold()) + { + for (auto __it =3D begin(); __it !=3D end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + + return { __it, false }; + } + + __hash_code __code =3D this->_M_hash_code(__k); + size_type __bkt =3D _M_bucket_index(__code); + if (size() > __small_size_threshold()) + if (__node_ptr __p =3D _M_find_node(__bkt, __k, __code)) + + return { iterator(__p), false }; + + + auto __pos =3D _M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node =3D nullptr; + return { __pos, true }; + } + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_emplace(const_iterator __hint, false_type , + _Args&&... __args) + -> iterator + { + + _Scoped_node __node { this, std::forward<_Args>(__args)... }; + const key_type& __k =3D _ExtractKey{}(__node._M_node->_M_v()); + + auto __res =3D this->_M_compute_hash_code(__hint, __k); + auto __pos + =3D _M_insert_multi_node(__res.first._M_cur, __res.second, + __node._M_node); + __node._M_node =3D nullptr; + return __pos; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_compute_hash_code(const_iterator __hint, const key_type& __k) const + -> pair + { + if (size() <=3D __small_size_threshold()) + { + if (__hint !=3D cend()) + { + for (auto __it =3D __hint; __it !=3D cend(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return { __it, this->_M_hash_code(*__it._M_cur) }; + } + + for (auto __it =3D cbegin(); __it !=3D __hint; ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return { __it, this->_M_hash_code(*__it._M_cur) }; + } + + 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 + { + const __rehash_state& __saved_state =3D _M_rehash_policy._M_state(); + std::pair __do_rehash + =3D _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, + __n_elt); + + if (__do_rehash.first) + { + _M_rehash(__do_rehash.second, __saved_state); + __bkt =3D _M_bucket_index(__code); + } + + this->_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 + { + const __rehash_state& __saved_state =3D _M_rehash_policy._M_state(); + std::pair __do_rehash + =3D _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); + + if (__do_rehash.first) + _M_rehash(__do_rehash.second, __saved_state); + + this->_M_store_code(*__node, __code); + const key_type& __k =3D _ExtractKey{}(__node->_M_v()); + size_type __bkt =3D _M_bucket_index(__code); + + + + __node_base_ptr __prev + =3D __builtin_expect(__hint !=3D nullptr, false) + && this->_M_equals(__k, __code, *__hint) + ? __hint + : _M_find_before_node(__bkt, __k, __code); + + if (__prev) + { + + __node->_M_nxt =3D __prev->_M_nxt; + __prev->_M_nxt =3D __node; + if (__builtin_expect(__prev =3D=3D __hint, false)) + + + if (__node->_M_nxt + && !this->_M_equals(__k, __code, *__node->_M_next())) + { + size_type __next_bkt =3D _M_bucket_index(*__node->_M_next()); + if (__next_bkt !=3D __bkt) + _M_buckets[__next_bkt] =3D __node; + } + } + else + + + + _M_insert_bucket_begin(__bkt, __node); + ++_M_element_count; + return iterator(__node); + } + + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_unique(_Kt&& __k, _Arg&& __v, + const _NodeGenerator& __node_gen) + -> pair + { + if (size() <=3D __small_size_threshold()) + for (auto __it =3D begin(); __it !=3D end(); ++__it) + if (this->_M_key_equals_tr(__k, *__it._M_cur)) + return { __it, false }; + + __hash_code __code =3D this->_M_hash_code_tr(__k); + size_type __bkt =3D _M_bucket_index(__code); + + if (size() > __small_size_threshold()) + if (__node_ptr __node =3D _M_find_node_tr(__bkt, __k, __code)) + return { iterator(__node), false }; + + _Scoped_node __node { + __node_builder_t::_S_build(std::forward<_Kt>(__k), + std::forward<_Arg>(__v), + __node_gen), + this + }; + auto __pos + =3D _M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node =3D nullptr; + return { __pos, true }; + } + + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert(const_iterator __hint, _Arg&& __v, + const _NodeGenerator& __node_gen, + false_type ) + -> iterator + { + + _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; + + + auto __res =3D this->_M_compute_hash_code( + __hint, _ExtractKey{}(__node._M_node->_M_v())); + + auto __pos + =3D _M_insert_multi_node(__res.first._M_cur, __res.second, + __node._M_node); + __node._M_node =3D nullptr; + return __pos; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + erase(const_iterator __it) + -> iterator + { + __node_ptr __n =3D __it._M_cur; + std::size_t __bkt =3D _M_bucket_index(*__n); + + + + + __node_base_ptr __prev_n =3D _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 =3D=3D _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 =3D _M_bucket_index(*__n->_M_next()); + if (__next_bkt !=3D __bkt) + _M_buckets[__next_bkt] =3D __prev_n; + } + + __prev_n->_M_nxt =3D __n->_M_nxt; + iterator __result(__n->_M_next()); + this->_M_deallocate_node(__n); + --_M_element_count; + + return __result; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_erase(true_type , const key_type& __k) + -> size_type + { + __node_base_ptr __prev_n; + __node_ptr __n; + std::size_t __bkt; + if (size() <=3D __small_size_threshold()) + { + __prev_n =3D _M_find_before_node(__k); + if (!__prev_n) + return 0; + + + __n =3D static_cast<__node_ptr>(__prev_n->_M_nxt); + __bkt =3D _M_bucket_index(*__n); + } + else + { + __hash_code __code =3D this->_M_hash_code(__k); + __bkt =3D _M_bucket_index(__code); + + + __prev_n =3D _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + + __n =3D static_cast<__node_ptr>(__prev_n->_M_nxt); + } + + _M_erase(__bkt, __prev_n, __n); + return 1; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_erase(false_type , const key_type& __k) + -> size_type + { + std::size_t __bkt; + __node_base_ptr __prev_n; + __node_ptr __n; + if (size() <=3D __small_size_threshold()) + { + __prev_n =3D _M_find_before_node(__k); + if (!__prev_n) + return 0; + + + __n =3D static_cast<__node_ptr>(__prev_n->_M_nxt); + __bkt =3D _M_bucket_index(*__n); + } + else + { + __hash_code __code =3D this->_M_hash_code(__k); + __bkt =3D _M_bucket_index(__code); + + + __prev_n =3D _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + __n =3D static_cast<__node_ptr>(__prev_n->_M_nxt); + } + + + + + + + + __node_ptr __n_last =3D __n->_M_next(); + while (__n_last && this->_M_node_equals(*__n, *__n_last)) + __n_last =3D __n_last->_M_next(); + + std::size_t __n_last_bkt =3D __n_last ? _M_bucket_index(*__n_last) := __bkt; + + + size_type __result =3D 0; + do + { + __node_ptr __p =3D __n->_M_next(); + this->_M_deallocate_node(__n); + __n =3D __p; + ++__result; + } + while (__n !=3D __n_last); + + _M_element_count -=3D __result; + if (__prev_n =3D=3D _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); + else if (__n_last_bkt !=3D __bkt) + _M_buckets[__n_last_bkt] =3D __prev_n; + __prev_n->_M_nxt =3D __n_last; + return __result; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + erase(const_iterator __first, const_iterator __last) + -> iterator + { + __node_ptr __n =3D __first._M_cur; + __node_ptr __last_n =3D __last._M_cur; + if (__n =3D=3D __last_n) + return iterator(__n); + + std::size_t __bkt =3D _M_bucket_index(*__n); + + __node_base_ptr __prev_n =3D _M_get_previous_node(__bkt, __n); + bool __is_bucket_begin =3D __n =3D=3D _M_bucket_begin(__bkt); + std::size_t __n_bkt =3D __bkt; + for (;;) + { + do + { + __node_ptr __tmp =3D __n; + __n =3D __n->_M_next(); + this->_M_deallocate_node(__tmp); + --_M_element_count; + if (!__n) + break; + __n_bkt =3D _M_bucket_index(*__n); + } + while (__n !=3D __last_n && __n_bkt =3D=3D __bkt); + if (__is_bucket_begin) + _M_remove_bucket_begin(__bkt, __n, __n_bkt); + if (__n =3D=3D __last_n) + break; + __is_bucket_begin =3D true; + __bkt =3D __n_bkt; + } + + if (__n && (__n_bkt !=3D __bkt || __is_bucket_begin)) + _M_buckets[__n_bkt] =3D __prev_n; + __prev_n->_M_nxt =3D __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()); + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + _M_element_count =3D 0; + _M_before_begin._M_nxt =3D nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + rehash(size_type __bkt_count) + { + const __rehash_state& __saved_state =3D _M_rehash_policy._M_state(); + __bkt_count + =3D std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), + __bkt_count); + __bkt_count =3D _M_rehash_policy._M_next_bkt(__bkt_count); + + if (__bkt_count !=3D _M_bucket_count) + _M_rehash(__bkt_count, __saved_state); + else + + + _M_rehash_policy._M_reset(__saved_state); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash(size_type __bkt_count, const __rehash_state& __state) + { + if (true) + { + _M_rehash_aux(__bkt_count, __unique_keys{}); + } + if (false) + { + + + _M_rehash_policy._M_reset(__state); + ; + } + } + + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __bkt_count, true_type ) + { + __buckets_ptr __new_buckets =3D _M_allocate_buckets(__bkt_count); + __node_ptr __p =3D _M_begin(); + _M_before_begin._M_nxt =3D nullptr; + std::size_t __bbegin_bkt =3D 0; + while (__p) + { + __node_ptr __next =3D __p->_M_next(); + std::size_t __bkt + =3D __hash_code_base::_M_bucket_index(*__p, __bkt_count); + if (!__new_buckets[__bkt]) + { + __p->_M_nxt =3D _M_before_begin._M_nxt; + _M_before_begin._M_nxt =3D __p; + __new_buckets[__bkt] =3D &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] =3D __p; + __bbegin_bkt =3D __bkt; + } + else + { + __p->_M_nxt =3D __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt =3D __p; + } + + __p =3D __next; + } + + _M_deallocate_buckets(); + _M_bucket_count =3D __bkt_count; + _M_buckets =3D __new_buckets; + } + + + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __bkt_count, false_type ) + { + __buckets_ptr __new_buckets =3D _M_allocate_buckets(__bkt_count); + __node_ptr __p =3D _M_begin(); + _M_before_begin._M_nxt =3D nullptr; + std::size_t __bbegin_bkt =3D 0; + std::size_t __prev_bkt =3D 0; + __node_ptr __prev_p =3D nullptr; + bool __check_bucket =3D false; + + while (__p) + { + __node_ptr __next =3D __p->_M_next(); + std::size_t __bkt + =3D __hash_code_base::_M_bucket_index(*__p, __bkt_count); + + if (__prev_p && __prev_bkt =3D=3D __bkt) + { + + + + __p->_M_nxt =3D __prev_p->_M_nxt; + __prev_p->_M_nxt =3D __p; + + + + + + + __check_bucket =3D true; + } + else + { + if (__check_bucket) + { + + + if (__prev_p->_M_nxt) + { + std::size_t __next_bkt + =3D __hash_code_base::_M_bucket_index( + *__prev_p->_M_next(), __bkt_count); + if (__next_bkt !=3D __prev_bkt) + __new_buckets[__next_bkt] =3D __prev_p; + } + __check_bucket =3D false; + } + + if (!__new_buckets[__bkt]) + { + __p->_M_nxt =3D _M_before_begin._M_nxt; + _M_before_begin._M_nxt =3D __p; + __new_buckets[__bkt] =3D &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] =3D __p; + __bbegin_bkt =3D __bkt; + } + else + { + __p->_M_nxt =3D __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt =3D __p; + } + } + __prev_p =3D __p; + __prev_bkt =3D __bkt; + __p =3D __next; + } + + if (__check_bucket && __prev_p->_M_nxt) + { + std::size_t __next_bkt + =3D __hash_code_base::_M_bucket_index(*__prev_p->_M_next(), + __bkt_count); + if (__next_bkt !=3D __prev_bkt) + __new_buckets[__next_bkt] =3D __prev_p; + } + + _M_deallocate_buckets(); + _M_bucket_count =3D __bkt_count; + _M_buckets =3D __new_buckets; + } + + + template class _Hash_merge_helper { }; + + + + + template + using _RequireNotAllocatorOrIntegral + =3D __enable_if_t, __is_allocator<_Hash>>:= :value>; + + + + +} +# 34 "/usr/include/c++/13/bits/unordered_map.h" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + using __umap_traits =3D __detail::_Hashtable_traits<_Cache, false, tru= e>; + + template, + typename _Pred =3D std::equal_to<_Key>, + typename _Alloc =3D std::allocator >, + typename _Tr =3D __umap_traits<__cache_default<_Key, _Hash>::value>> + using __umap_hashtable =3D _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 =3D __detail::_Hashtable_traits<_Cache, false, fa= lse>; + + template, + typename _Pred =3D std::equal_to<_Key>, + typename _Alloc =3D std::allocator >, + typename _Tr =3D __ummap_traits<__cache_default<_Key, _Hash>::value>> + using __ummap_hashtable =3D _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; +# 103 "/usr/include/c++/13/bits/unordered_map.h" 3 + template, + typename _Pred =3D equal_to<_Key>, + typename _Alloc =3D 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_iterat= or; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + + + + using node_type =3D typename _Hashtable::node_type; + using insert_return_type =3D typename _Hashtable::insert_return_type; + + + + + + unordered_map() =3D default; +# 155 "/usr/include/c++/13/bits/unordered_map.h" 3 + explicit + unordered_map(size_type __n, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } +# 176 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + unordered_map(_InputIterator __first, _InputIterator __last, + size_type __n =3D 0, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _M_h(__first, __last, __n, __hf, __eql, __a) + { } + + + unordered_map(const unordered_map&) =3D default; + + + unordered_map(unordered_map&&) =3D 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) + { } +# 232 "/usr/include/c++/13/bits/unordered_map.h" 3 + unordered_map(initializer_list __l, + size_type __n =3D 0, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D 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) + { } + + + unordered_map& + operator=3D(const unordered_map&) =3D default; + + + unordered_map& + operator=3D(unordered_map&&) =3D default; +# 294 "/usr/include/c++/13/bits/unordered_map.h" 3 + unordered_map& + operator=3D(initializer_list __l) + { + _M_h =3D __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(); } +# 391 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + std::pair + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } +# 422 "/usr/include/c++/13/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 !=3D end())) __bui= ltin_unreachable(); } 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; } +# 474 "/usr/include/c++/13/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)...); + } +# 518 "/usr/include/c++/13/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; + } +# 555 "/usr/include/c++/13/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)); } +# 594 "/usr/include/c++/13/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)); } +# 619 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } +# 631 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + insert(initializer_list __l) + { _M_h.insert(__l); } +# 657 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + pair + insert_or_assign(const key_type& __k, _Obj&& __obj) + { + auto __ret =3D _M_h.try_emplace(cend(), __k, + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second =3D std::forward<_Obj>(__obj); + return __ret; + } + + + template + pair + insert_or_assign(key_type&& __k, _Obj&& __obj) + { + auto __ret =3D _M_h.try_emplace(cend(), std::move(__k), + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second =3D std::forward<_Obj>(__obj); + return __ret; + } +# 706 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + iterator + insert_or_assign(const_iterator __hint, const key_type& __k, + _Obj&& __obj) + { + auto __ret =3D _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second =3D std::forward<_Obj>(__obj); + return __ret.first; + } + + + template + iterator + insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) + { + auto __ret =3D _M_h.try_emplace(__hint, std::move(__k), + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second =3D std::forward<_Obj>(__obj); + return __ret.first; + } +# 744 "/usr/include/c++/13/bits/unordered_map.h" 3 + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + + iterator + erase(iterator __position) + { return _M_h.erase(__position); } +# 766 "/usr/include/c++/13/bits/unordered_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } +# 784 "/usr/include/c++/13/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(); } +# 808 "/usr/include/c++/13/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) + { + using _Merge_helper =3D _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) + { merge(__source); } + + template + void + merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper =3D _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(); } +# 872 "/usr/include/c++/13/bits/unordered_map.h" 3 + iterator + find(const key_type& __x) + { return _M_h.find(__x); } +# 883 "/usr/include/c++/13/bits/unordered_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } +# 905 "/usr/include/c++/13/bits/unordered_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } +# 945 "/usr/include/c++/13/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } +# 957 "/usr/include/c++/13/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } +# 983 "/usr/include/c++/13/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)]; } +# 1000 "/usr/include/c++/13/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); } +# 1056 "/usr/include/c++/13/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); } +# 1071 "/usr/include/c++/13/bits/unordered_map.h" 3 + local_iterator + end(size_type __n) + { return _M_h.end(__n); } +# 1082 "/usr/include/c++/13/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); } +# 1119 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + rehash(size_type __n) + { _M_h.rehash(__n); } +# 1130 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator=3D=3D(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, + const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); + }; + + + + template>, + typename _Pred =3D equal_to<__iter_key_t<_InputIterator>>, + typename _Allocator =3D allocator<__iter_to_alloc_t<_InputIterator>>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _RequireNotAllocator<_Pred>, + typename =3D _RequireAllocator<_Allocator>> + unordered_map(_InputIterator, _InputIterator, + typename unordered_map::size_type =3D {}, + _Hash =3D _Hash(), _Pred =3D _Pred(), _Allocator =3D _Allocator()) + -> unordered_map<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + _Hash, _Pred, _Allocator>; + + template, + typename _Pred =3D equal_to<_Key>, + typename _Allocator =3D allocator>, + typename =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _RequireNotAllocator<_Pred>, + typename =3D _RequireAllocator<_Allocator>> + unordered_map(initializer_list>, + typename unordered_map::size_type =3D {}, + _Hash =3D _Hash(), _Pred =3D _Pred(), _Allocator =3D _Allocator()) + -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>; + + template, + typename =3D _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 =3D _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 =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _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 =3D _RequireAllocator<_Allocator>> + unordered_map(initializer_list>, + typename unordered_map::size_type, + _Hash, _Allocator) + -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; +# 1246 "/usr/include/c++/13/bits/unordered_map.h" 3 + template, + typename _Pred =3D equal_to<_Key>, + typename _Alloc =3D allocator>> + class unordered_multimap + { + typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtabl= e; + _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_iterat= or; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + + + + using node_type =3D typename _Hashtable::node_type; + + + + + + unordered_multimap() =3D default; +# 1297 "/usr/include/c++/13/bits/unordered_map.h" 3 + explicit + unordered_multimap(size_type __n, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } +# 1318 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + unordered_multimap(_InputIterator __first, _InputIterator __last, + size_type __n =3D 0, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D allocator_type()) + : _M_h(__first, __last, __n, __hf, __eql, __a) + { } + + + unordered_multimap(const unordered_multimap&) =3D default; + + + unordered_multimap(unordered_multimap&&) =3D 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) + { } +# 1374 "/usr/include/c++/13/bits/unordered_map.h" 3 + unordered_multimap(initializer_list __l, + size_type __n =3D 0, + const hasher& __hf =3D hasher(), + const key_equal& __eql =3D key_equal(), + const allocator_type& __a =3D 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) + { } + + + unordered_multimap& + operator=3D(const unordered_multimap&) =3D default; + + + unordered_multimap& + operator=3D(unordered_multimap&&) =3D default; +# 1436 "/usr/include/c++/13/bits/unordered_map.h" 3 + unordered_multimap& + operator=3D(initializer_list __l) + { + _M_h =3D __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(); } +# 1528 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + iterator + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } +# 1555 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } +# 1570 "/usr/include/c++/13/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)); } +# 1604 "/usr/include/c++/13/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)); } +# 1629 "/usr/include/c++/13/bits/unordered_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } +# 1642 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos !=3D end())) __bui= ltin_unreachable(); } 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)); } +# 1685 "/usr/include/c++/13/bits/unordered_map.h" 3 + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + + iterator + erase(iterator __position) + { return _M_h.erase(__position); } +# 1706 "/usr/include/c++/13/bits/unordered_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } +# 1725 "/usr/include/c++/13/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(); } +# 1749 "/usr/include/c++/13/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) + { + using _Merge_helper + =3D _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) + { merge(__source); } + + template + void + merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper + =3D _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(); } +# 1815 "/usr/include/c++/13/bits/unordered_map.h" 3 + iterator + find(const key_type& __x) + { return _M_h.find(__x); } +# 1826 "/usr/include/c++/13/bits/unordered_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } +# 1844 "/usr/include/c++/13/bits/unordered_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } +# 1882 "/usr/include/c++/13/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } +# 1894 "/usr/include/c++/13/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } +# 1910 "/usr/include/c++/13/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); } +# 1954 "/usr/include/c++/13/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); } +# 1969 "/usr/include/c++/13/bits/unordered_map.h" 3 + local_iterator + end(size_type __n) + { return _M_h.end(__n); } +# 1980 "/usr/include/c++/13/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); } +# 2017 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + rehash(size_type __n) + { _M_h.rehash(__n); } +# 2028 "/usr/include/c++/13/bits/unordered_map.h" 3 + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator=3D=3D(const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&, + const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&); + }; + + + + template>, + typename _Pred =3D equal_to<__iter_key_t<_InputIterator>>, + typename _Allocator =3D allocator<__iter_to_alloc_t<_InputIterator>>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _RequireNotAllocator<_Pred>, + typename =3D _RequireAllocator<_Allocator>> + unordered_multimap(_InputIterator, _InputIterator, + unordered_multimap::size_type =3D {}, + _Hash =3D _Hash(), _Pred =3D _Pred(), + _Allocator =3D _Allocator()) + -> unordered_multimap<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, _Hash, _Pred, + _Allocator>; + + template, + typename _Pred =3D equal_to<_Key>, + typename _Allocator =3D allocator>, + typename =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _RequireNotAllocator<_Pred>, + typename =3D _RequireAllocator<_Allocator>> + unordered_multimap(initializer_list>, + unordered_multimap::size_type =3D {}, + _Hash =3D _Hash(), _Pred =3D _Pred(), + _Allocator =3D _Allocator()) + -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>; + + template, + typename =3D _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 =3D _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 =3D _RequireNotAllocatorOrIntegral<_Hash>, + typename =3D _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>, _Allocato= r>; + + template> + unordered_multimap(initializer_list>, _Allocator) + -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocato= r>; + + template, + typename =3D _RequireAllocator<_Allocator>> + unordered_multimap(initializer_list>, + unordered_multimap::size_type, + _Hash, _Allocator) + -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; + + + + 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=3D=3D(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!=3D(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator=3D=3D(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allo= c>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + + template + inline bool + operator!=3D(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>= & __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + + + + + template + struct _Hash_merge_helper< + std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>, + _Hash2, _Eq2> + { + private: + template + using unordered_map =3D std::unordered_map<_Tp...>; + template + using unordered_multimap =3D 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 =3D std::unordered_map<_Tp...>; + template + using unordered_multimap =3D 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; } + }; + + + +} +# 42 "/usr/include/c++/13/unordered_map" 2 3 + +# 1 "/usr/include/c++/13/bits/erase_if.h" 1 3 +# 33 "/usr/include/c++/13/bits/erase_if.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/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 =3D 0; + for (auto __iter =3D __ucont.begin(), __last =3D __ucont.end(); + __iter !=3D __last;) + { + if (__pred(*__iter)) + { + __iter =3D __cont.erase(__iter); + ++__num; + } + else + ++__iter; + } + return __num; + } + } + + +} +# 44 "/usr/include/c++/13/unordered_map" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr + { + template, + typename _Pred =3D std::equal_to<_Key>> + using unordered_map + =3D std::unordered_map<_Key, _Tp, _Hash, _Pred, + polymorphic_allocator>>; + template, + typename _Pred =3D std::equal_to<_Key>> + using unordered_multimap + =3D std::unordered_multimap<_Key, _Tp, _Hash, _Pred, + polymorphic_allocator>>; + } + +} +# 64 "/usr/include/c++/13/functional" 2 3 + +# 1 "/usr/include/c++/13/array" 1 3 +# 32 "/usr/include/c++/13/array" 3 +=20=20=20=20=20=20=20 +# 33 "/usr/include/c++/13/array" 3 + + + + + +# 1 "/usr/include/c++/13/compare" 1 3 +# 33 "/usr/include/c++/13/compare" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/compare" 3 +# 39 "/usr/include/c++/13/array" 2 3 +# 48 "/usr/include/c++/13/array" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + struct __array_traits + { + using _Type =3D _Tp[_Nm]; + using _Is_swappable =3D __is_swappable<_Tp>; + using _Is_nothrow_swappable =3D __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 operator _Tp*() const noexcept { return nullptr; } + }; + + using _Is_swappable =3D true_type; + using _Is_nothrow_swappable =3D true_type; + }; +# 93 "/usr/include/c++/13/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() =3D=3D 0; } + + + [[__nodiscard__]] + constexpr reference + operator[](size_type __n) noexcept + { + ; + return _M_elems[__n]; + } + + [[__nodiscard__]] + constexpr const_reference + operator[](size_type __n) const noexcept + { + + ; + + return _M_elems[__n]; + } + + constexpr reference + at(size_type __n) + { + if (__n >=3D _Nm) + std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">=3D _= 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) " ">= =3D _Nm (which is %zu)") + , + __n, _Nm), + _M_elems[__n]); + } + + [[__nodiscard__]] + constexpr reference + front() noexcept + { + ; + return _M_elems[0]; + } + + [[__nodiscard__]] + constexpr const_reference + front() const noexcept + { + + ; + + return _M_elems[0]; + } + + [[__nodiscard__]] + constexpr reference + back() noexcept + { + ; + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__]] + constexpr const_reference + back() const noexcept + { + + ; + + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr pointer + data() noexcept + { return _M_elems; } + + [[__nodiscard__]] + constexpr const_pointer + data() const noexcept + { return _M_elems; } + }; + + + template + array(_Tp, _Up...) + -> array && ...), _Tp>, + 1 + sizeof...(_Up)>; + + + + template + [[__nodiscard__]] +=20=20=20 + inline bool + operator=3D=3D(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __= two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } +# 322 "/usr/include/c++/13/array" 3 + template + [[__nodiscard__]] +=20=20=20 + inline bool + operator!=3D(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __tw= o) + { return !(__one =3D=3D __two); } + + template + [[__nodiscard__]] +=20=20=20 + 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__]] +=20=20=20 + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + [[__nodiscard__]] +=20=20=20 + inline bool + operator<=3D(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __tw= o) + { return !(__one > __two); } + + template + [[__nodiscard__]] +=20=20=20 + inline bool + operator>=3D(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __tw= o) + { return !(__one < __two); } + + + + template +=20=20=20 + 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>&) =3D 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)); + } +# 460 "/usr/include/c++/13/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 =3D _Tp; + }; + + + template + inline constexpr size_t tuple_size_v> =3D _Nm; + + template + inline constexpr size_t tuple_size_v> =3D _Nm; + + + template + struct __is_tuple_like_impl> : true_type + { }; + + +} +# 66 "/usr/include/c++/13/functional" 2 3 + +# 1 "/usr/include/c++/13/bits/stl_algo.h" 1 3 +# 59 "/usr/include/c++/13/bits/stl_algo.h" 3 +# 1 "/usr/include/c++/13/bits/algorithmfwd.h" 1 3 +# 33 "/usr/include/c++/13/bits/algorithmfwd.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/algorithmfwd.h" 3 +# 42 "/usr/include/c++/13/bits/algorithmfwd.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 199 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template +=20=20=20 + bool + all_of(_IIter, _IIter, _Predicate); + + template +=20=20=20 + bool + any_of(_IIter, _IIter, _Predicate); + + + template +=20=20=20 + bool + binary_search(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + 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 +=20=20=20 + _OIter + copy(_IIter, _IIter, _OIter); + + template +=20=20=20 + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); + + + template +=20=20=20 + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template +=20=20=20 + _OIter + copy_n(_IIter, _Size, _OIter); + + + + + + template +=20=20=20 + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template +=20=20=20 + void + fill(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + _OIter + fill_n(_OIter, _Size, const _Tp&); + + + + template +=20=20=20 + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template +=20=20=20 + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + + + + + template +=20=20=20 + _IIter + find_if_not(_IIter, _IIter, _Predicate); + + + + + + + template +=20=20=20 + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template +=20=20=20 + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + + template +=20=20=20 + bool + is_heap(_RAIter, _RAIter); + + template +=20=20=20 + bool + is_heap(_RAIter, _RAIter, _Compare); + + template +=20=20=20 + _RAIter + is_heap_until(_RAIter, _RAIter); + + template +=20=20=20 + _RAIter + is_heap_until(_RAIter, _RAIter, _Compare); + + template +=20=20=20 + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template +=20=20=20 + bool + is_permutation(_FIter1, _FIter1, _FIter2); + + template +=20=20=20 + bool + is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); + + template +=20=20=20 + bool + is_sorted(_FIter, _FIter); + + template +=20=20=20 + bool + is_sorted(_FIter, _FIter, _Compare); + + template +=20=20=20 + _FIter + is_sorted_until(_FIter, _FIter); + + template +=20=20=20 + _FIter + is_sorted_until(_FIter, _FIter, _Compare); + + + template +=20=20=20 + void + iter_swap(_FIter1, _FIter2); + + template +=20=20=20 + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template +=20=20=20 + void + make_heap(_RAIter, _RAIter); + + template +=20=20=20 + 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 +=20=20=20 + bool + next_permutation(_BIter, _BIter); + + template +=20=20=20 + bool + next_permutation(_BIter, _BIter, _Compare); + + + template +=20=20=20 + bool + none_of(_IIter, _IIter, _Predicate); + + + + + + template +=20=20=20 + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template +=20=20=20 + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + + + + template +=20=20=20 + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); + + template +=20=20=20 + _FIter + partition_point(_FIter, _FIter, _Predicate); + + + template +=20=20=20 + void + pop_heap(_RAIter, _RAIter); + + template +=20=20=20 + void + pop_heap(_RAIter, _RAIter, _Compare); + + template +=20=20=20 + bool + prev_permutation(_BIter, _BIter); + + template +=20=20=20 + bool + prev_permutation(_BIter, _BIter, _Compare); + + template +=20=20=20 + void + push_heap(_RAIter, _RAIter); + + template +=20=20=20 + void + push_heap(_RAIter, _RAIter, _Compare); + + + + template +=20=20=20 + _FIter + remove(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template +=20=20=20 + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template +=20=20=20 + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + + + template +=20=20=20 + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template +=20=20=20 + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + + + template +=20=20=20 + void + reverse(_BIter, _BIter); + + template +=20=20=20 + _OIter + reverse_copy(_BIter, _BIter, _OIter); + +inline namespace _V2 { + + template +=20=20=20 + _FIter + rotate(_FIter, _FIter, _FIter); + +} + + template +=20=20=20 + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); +# 626 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template + void + shuffle(_RAIter, _RAIter, _UGenerator&&); + + + template +=20=20=20 + void + sort_heap(_RAIter, _RAIter); + + template +=20=20=20 + void + sort_heap(_RAIter, _RAIter, _Compare); + + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); +# 661 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template +=20=20=20 + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + + + template +=20=20=20 + _FIter + unique(_FIter, _FIter); + + template +=20=20=20 + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + + + template +=20=20=20 + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template +=20=20=20 + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + + + template +=20=20=20 + _FIter + adjacent_find(_FIter, _FIter); + + template +=20=20=20 + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template +=20=20=20 + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template +=20=20=20 + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template +=20=20=20 + bool + equal(_IIter1, _IIter1, _IIter2); + + template +=20=20=20 + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template +=20=20=20 + _IIter + find(_IIter, _IIter, const _Tp&); + + template +=20=20=20 + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template +=20=20=20 + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template +=20=20=20 + _IIter + find_if(_IIter, _IIter, _Predicate); + + template +=20=20=20 + _Funct + for_each(_IIter, _IIter, _Funct); + + template +=20=20=20 + void + generate(_FIter, _FIter, _Generator); + + template +=20=20=20 + _OIter + generate_n(_OIter, _Size, _Generator); + + template +=20=20=20 + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template +=20=20=20 + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + constexpr + _FIter + max_element(_FIter, _FIter); + + template + constexpr + _FIter + max_element(_FIter, _FIter, _Compare); + + template +=20=20=20 + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template +=20=20=20 + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + constexpr + _FIter + min_element(_FIter, _FIter); + + template + constexpr + _FIter + min_element(_FIter, _FIter, _Compare); + + template +=20=20=20 + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template +=20=20=20 + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template +=20=20=20 + void + nth_element(_RAIter, _RAIter, _RAIter); + + template +=20=20=20 + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template +=20=20=20 + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template +=20=20=20 + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template +=20=20=20 + _BIter + partition(_BIter, _BIter, _Predicate); + + + template + void + random_shuffle(_RAIter, _RAIter); + + template + void + random_shuffle(_RAIter, _RAIter, + + _Generator&&); + + + + + + template +=20=20=20 + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template +=20=20=20 + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template +=20=20=20 + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template +=20=20=20 + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template +=20=20=20 + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template +=20=20=20 + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template +=20=20=20 + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template +=20=20=20 + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template +=20=20=20 + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template +=20=20=20 + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template +=20=20=20 + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template +=20=20=20 + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template +=20=20=20 + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template +=20=20=20 + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template +=20=20=20 + void + sort(_RAIter, _RAIter); + + template +=20=20=20 + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template +=20=20=20 + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template +=20=20=20 + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template +=20=20=20 + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template +=20=20=20 + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + + +} +# 60 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + +# 1 "/usr/include/c++/13/bits/stl_heap.h" 1 3 +# 63 "/usr/include/c++/13/bits/stl_heap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template +=20=20=20 + _Distance + __is_heap_until(_RandomAccessIterator __first, _Distance __n, + _Compare& __comp) + { + _Distance __parent =3D 0; + for (_Distance __child =3D 1; __child < __n; ++__child) + { + if (__comp(__first + __parent, __first + __child)) + return __child; + if ((__child & 1) =3D=3D 0) + ++__parent; + } + return __n; + } + + + + template +=20=20=20 + inline bool + __is_heap(_RandomAccessIterator __first, _Distance __n) + { + __gnu_cxx::__ops::_Iter_less_iter __comp; + return std::__is_heap_until(__first, __n, __comp) =3D=3D __n; + } + + template +=20=20=20 + 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) =3D=3D __n; + } + + template +=20=20=20 + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template +=20=20=20 + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + return std::__is_heap(__first, std::move(__comp), + std::distance(__first, __last)); + } + + + + + template +=20=20=20 + void + __push_heap(_RandomAccessIterator __first, + _Distance __holeIndex, _Distance __topIndex, _Tp __value, + _Compare& __comp) + { + _Distance __parent =3D (__holeIndex - 1) / 2; + while (__holeIndex > __topIndex && __comp(__first + __parent, __valu= e)) + { + *(__first + __holeIndex) =3D std::move(*(__first + __parent)); + __holeIndex =3D __parent; + __parent =3D (__holeIndex - 1) / 2; + } + *(__first + __holeIndex) =3D std::move(__value); + } +# 159 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_= type + _DistanceType; + + +=20=20=20=20=20 + +=20=20=20=20=20 + ; + ; + ; + + __gnu_cxx::__ops::_Iter_less_val __comp; + _ValueType __value =3D std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), __comp); + } +# 195 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + 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; + + +=20=20=20=20=20 + + ; + ; + ; + + __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) + __cmp(std::move(__comp)); + _ValueType __value =3D std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), __cmp); + } + + template +=20=20=20 + void + __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, + _Distance __len, _Tp __value, _Compare __comp) + { + const _Distance __topIndex =3D __holeIndex; + _Distance __secondChild =3D __holeIndex; + while (__secondChild < (__len - 1) / 2) + { + __secondChild =3D 2 * (__secondChild + 1); + if (__comp(__first + __secondChild, + __first + (__secondChild - 1))) + __secondChild--; + *(__first + __holeIndex) =3D std::move(*(__first + __secondChild)); + __holeIndex =3D __secondChild; + } + if ((__len & 1) =3D=3D 0 && __secondChild =3D=3D (__len - 2) / 2) + { + __secondChild =3D 2 * (__secondChild + 1); + *(__first + __holeIndex) =3D std::move(*(__first + (__secondChild - 1))) + ; + __holeIndex =3D __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 +=20=20=20 + 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 =3D std::move(*__result); + *__result =3D std::move(*__first); + std::__adjust_heap(__first, _DistanceType(0), + _DistanceType(__last - __first), + std::move(__value), __comp); + } +# 280 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 314 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + pop_heap(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + +=20=20=20=20=20 + + ; + ; + ; + ; + + 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 +=20=20=20 + void + __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __las= t, + _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 =3D __last - __first; + _DistanceType __parent =3D (__len - 2) / 2; + while (true) + { + _ValueType __value =3D std::move(*(__first + __parent)); + std::__adjust_heap(__first, __parent, __len, std::move(__value), + __comp); + if (__parent =3D=3D 0) + return; + __parent--; + } + } +# 372 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__make_heap(__first, __last, __comp); + } +# 399 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + + ; + ; + + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + std::__make_heap(__first, __last, __cmp); + } + + template +=20=20=20 + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __las= t, + _Compare& __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 437 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__sort_heap(__first, __last, __comp); + } +# 465 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + + ; + ; + ; + + 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++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __l= ast) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), __comp); + } +# 523 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __l= ast, + _Compare __comp) + { + +=20=20=20=20=20 + + ; + ; + + 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++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::is_heap_until(__first, __last) =3D=3D __last; } +# 562 "/usr/include/c++/13/bits/stl_heap.h" 3 + template +=20=20=20 + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + + ; + ; + + const auto __dist =3D 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) =3D=3D __dist; + } + + + +} +# 62 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + + + +# 1 "/usr/include/c++/13/bits/uniform_int_dist.h" 1 3 +# 41 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 58 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + namespace __detail + { + + + + template + constexpr bool + _Power_of_2(_Tp __x) + { + return ((__x - 1) & __x) =3D=3D 0; + } + } + + + + + + + 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 =3D __gnu_cxx::__int_traits<_IntType>::__max) + : _M_a(__a), _M_b(__b) + { + do { if (std::__is_constant_evaluated() && !bool(_M_a <=3D _M_b)) __bui= ltin_unreachable(); } while (false); + } + + result_type + a() const + { return _M_a; } + + result_type + b() const + { return _M_b; } + + friend bool + operator=3D=3D(const param_type& __p1, const param_type& __p2) + { return __p1._M_a =3D=3D __p2._M_a && __p1._M_b =3D=3D __p2._M_b; } + + friend bool + operator!=3D(const param_type& __p1, const param_type& __p2) + { return !(__p1 =3D=3D __p2); } + + private: + _IntType _M_a; + _IntType _M_b; + }; + + public: + + + + uniform_int_distribution() : uniform_int_distribution(0) { } + + + + + explicit + uniform_int_distribution(_IntType __a, + _IntType __b + =3D __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 =3D __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=3D=3D(const uniform_int_distribution& __d1, + const uniform_int_distribution& __d2) + { return __d1._M_param =3D=3D __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 =3D __gnu_cxx::__int_traits<_Up>; + using _Wp_traits =3D __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 =3D=3D (2 * _Up_traits::__digits), + "W must be twice as wide as U"); + + + + + _Wp __product =3D _Wp(__g()) * _Wp(__range); + _Up __low =3D _Up(__product); + if (__low < __range) + { + _Up __threshold =3D -__range % __range; + while (__low < __threshold) + { + __product =3D _Wp(__g()) * _Wp(__range); + __low =3D _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 =3D _UniformRandomBitGenerator::min(); + constexpr __uctype __urngmax =3D _UniformRandomBitGenerator::max(); + static_assert( __urngmin < __urngmax, + "Uniform random bit generator must define min() < max()"); + constexpr __uctype __urngrange =3D __urngmax - __urngmin; + + const __uctype __urange + =3D __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + if (__urngrange > __urange) + { + + + const __uctype __uerange =3D __urange + 1; + + + + if constexpr (__urngrange =3D=3D 0xffffffffffffffffUL) + { + + + long unsigned int __u64erange =3D __uerange; + __ret =3D __extension__ _S_nd(__urng, + __u64erange); + } + else + + if constexpr (__urngrange =3D=3D 0xffffffffU) + { + + + unsigned int __u32erange =3D __uerange; + __ret =3D _S_nd(__urng, __u32erange); + } + else + + { + + const __uctype __scaling =3D __urngrange / __uerange; + const __uctype __past =3D __uerange * __scaling; + do + __ret =3D __uctype(__urng()) - __urngmin; + while (__ret >=3D __past); + __ret /=3D __scaling; + } + } + else if (__urngrange < __urange) + { +# 348 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + __uctype __tmp; + do + { + const __uctype __uerngrange =3D __urngrange + 1; + __tmp =3D (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret =3D __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + } + else + __ret =3D __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 =3D __urng.min(); + constexpr __uctype __urngmax =3D __urng.max(); + constexpr __uctype __urngrange =3D __urngmax - __urngmin; + const __uctype __urange + =3D __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 !=3D __t) + { + __ret =3D __uctype(__urng()) - __urngmin; + *__f++ =3D (__ret & __urange) + __param.a(); + } + } + else + { + + const __uctype __uerange =3D __urange + 1; + const __uctype __scaling =3D __urngrange / __uerange; + const __uctype __past =3D __uerange * __scaling; + while (__f !=3D __t) + { + do + __ret =3D __uctype(__urng()) - __urngmin; + while (__ret >=3D __past); + *__f++ =3D __ret / __scaling + __param.a(); + } + } + } + else if (__urngrange < __urange) + { +# 433 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + __uctype __tmp; + while (__f !=3D __t) + { + do + { + constexpr __uctype __uerngrange =3D __urngrange + 1; + __tmp =3D (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret =3D __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + *__f++ =3D __ret; + } + } + else + while (__f !=3D __t) + *__f++ =3D __uctype(__urng()) - __urngmin + __param.a(); + } + + + + +} +# 66 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + + + + + +# 1 "/usr/include/c++/13/cstdlib" 1 3 +# 39 "/usr/include/c++/13/cstdlib" 3 +=20=20=20=20=20=20=20 +# 40 "/usr/include/c++/13/cstdlib" 3 +# 72 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template +=20=20=20 + 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 +=20=20=20 + inline _InputIterator + __find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__negate(__pred), + std::__iterator_category(__first)); + } + + + + + template +=20=20=20 + _InputIterator + __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate _= _pred) + { + for (; __len; --__len, (void) ++__first) + if (!__pred(__first)) + break; + return __first; + } +# 144 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 =3D=3D __last1 || __first2 =3D=3D __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 =3D=3D __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator1 __current =3D __first1; + + for (;;) + { + __first1 =3D + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 =3D=3D __last1) + return __last1; + + _ForwardIterator2 __p =3D __p1; + __current =3D __first1; + if (++__current =3D=3D __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p =3D=3D __last2) + return __first1; + if (++__current =3D=3D __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + + + + + template +=20=20=20 + _ForwardIterator + __search_n_aux(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::forward_iterator_tag) + { + __first =3D std::__find_if(__first, __last, __unary_pred); + while (__first !=3D __last) + { + typename iterator_traits<_ForwardIterator>::difference_type + __n =3D __count; + _ForwardIterator __i =3D __first; + ++__i; + while (__i !=3D __last && __n !=3D 1 && __unary_pred(__i)) + { + ++__i; + --__n; + } + if (__n =3D=3D 1) + return __first; + if (__i =3D=3D __last) + return __last; + __first =3D std::__find_if(++__i, __last, __unary_pred); + } + return __last; + } + + + + + + template +=20=20=20 + _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 =3D __last - __first; + _DistanceType __remainder =3D __count; + + while (__remainder <=3D __tailSize) + { + __first +=3D __remainder; + __tailSize -=3D __remainder; + + + _RandomAccessIter __backTrack =3D __first; + while (__unary_pred(--__backTrack)) + { + if (--__remainder =3D=3D 0) + return (__first - __count); + } + __remainder =3D __count + 1 - (__first - __backTrack); + } + return __last; + } + + template +=20=20=20 + _ForwardIterator + __search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, + _UnaryPredicate __unary_pred) + { + if (__count <=3D 0) + return __first; + + if (__count =3D=3D 1) + return std::__find_if(__first, __last, __unary_pred); + + return std::__search_n_aux(__first, __last, __count, __unary_pred, + std::__iterator_category(__first)); + } + + + template +=20=20=20 + _ForwardIterator1 + __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + forward_iterator_tag, forward_iterator_tag, + _BinaryPredicate __comp) + { + if (__first2 =3D=3D __last2) + return __last1; + + _ForwardIterator1 __result =3D __last1; + while (1) + { + _ForwardIterator1 __new_result + =3D std::__search(__first1, __last1, __first2, __last2, __comp); + if (__new_result =3D=3D __last1) + return __result; + else + { + __result =3D __new_result; + __first1 =3D __new_result; + ++__first1; + } + } + } + + + template +=20=20=20 + _BidirectionalIterator1 + __find_end(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + bidirectional_iterator_tag, bidirectional_iterator_tag, + _BinaryPredicate __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; + typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; + + _RevIterator1 __rlast1(__first1); + _RevIterator2 __rlast2(__first2); + _RevIterator1 __rresult =3D std::__search(_RevIterator1(__last1), __= rlast1, + _RevIterator2(__last2), __rlast2, + __comp); + + if (__rresult =3D=3D __rlast1) + return __last1; + else + { + _BidirectionalIterator1 __result =3D __rresult.base(); + std::advance(__result, -std::distance(__first2, __last2)); + return __result; + } + } +# 370 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 419 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 455 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + all_of(_InputIterator __first, _InputIterator __last, _Predicate __pre= d) + { return __last =3D=3D std::find_if_not(__first, __last, __pred); } +# 473 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + none_of(_InputIterator __first, _InputIterator __last, _Predicate __pr= ed) + { return __last =3D=3D std::find_if(__first, __last, __pred); } +# 492 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + any_of(_InputIterator __first, _InputIterator __last, _Predicate __pre= d) + { return !std::none_of(__first, __last, __pred); } +# 508 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _InputIterator + find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + return std::__find_if_not(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 533 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + is_partitioned(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + __first =3D std::find_if_not(__first, __last, __pred); + if (__first =3D=3D __last) + return true; + ++__first; + return std::none_of(__first, __last, __pred); + } +# 555 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _ForwardIterator + partition_point(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + + ; + + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len =3D std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half =3D __len >> 1; + _ForwardIterator __middle =3D __first; + std::advance(__middle, __half); + if (__pred(*__middle)) + { + __first =3D __middle; + ++__first; + __len =3D __len - __half - 1; + } + else + __len =3D __half; + } + return __first; + } + + + template +=20=20=20 + _OutputIterator + __remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + for (; __first !=3D __last; ++__first) + if (!__pred(__first)) + { + *__result =3D *__first; + ++__result; + } + return __result; + } +# 622 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + remove_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, const _Tp& __value) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 655 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 690 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _OutputIterator + copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + for (; __first !=3D __last; ++__first) + if (__pred(*__first)) + { + *__result =3D *__first; + ++__result; + } + return __result; + } + + template +=20=20=20 + _OutputIterator + __copy_n(_InputIterator __first, _Size __n, + _OutputIterator __result, input_iterator_tag) + { + return std::__niter_wrap(__result, + __copy_n_a(__first, __n, + std::__niter_base(__result), true)); + } + + template +=20=20=20 + inline _OutputIterator + __copy_n(_RandomAccessIterator __first, _Size __n, + _OutputIterator __result, random_access_iterator_tag) + { return std::copy(__first, __first + __n, __result); } +# 746 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + const auto __n2 =3D std::__size_to_integer(__n); + if (__n2 <=3D 0) + return __result; + + ; + ; + + return std::__copy_n(__first, __n2, __result, + std::__iterator_category(__first)); + } +# 782 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + pair<_OutputIterator1, _OutputIterator2> + partition_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, + _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + for (; __first !=3D __last; ++__first) + if (__pred(*__first)) + { + *__out_true =3D *__first; + ++__out_true; + } + else + { + *__out_false =3D *__first; + ++__out_false; + } + + return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_fa= lse); + } +# 833 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + remove(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 867 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + template +=20=20=20 + _ForwardIterator + __adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + if (__first =3D=3D __last) + return __last; + _ForwardIterator __next =3D __first; + while (++__next !=3D __last) + { + if (__binary_pred(__first, __next)) + return __first; + __first =3D __next; + } + return __last; + } + + template +=20=20=20 + _ForwardIterator + __unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + __first =3D std::__adjacent_find(__first, __last, __binary_pred); + if (__first =3D=3D __last) + return __last; + + + _ForwardIterator __dest =3D __first; + ++__first; + while (++__first !=3D __last) + if (!__binary_pred(__dest, __first)) + *++__dest =3D std::move(*__first); + return ++__dest; + } +# 936 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 967 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + + + template +=20=20=20 + _OutputIterator + __unique_copy(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + forward_iterator_tag, output_iterator_tag) + { + +=20=20=20=20=20 + + + + _ForwardIterator __next =3D __first; + *__result =3D *__first; + while (++__next !=3D __last) + if (!__binary_pred(__first, __next)) + { + __first =3D __next; + *++__result =3D *__first; + } + return ++__result; + } + + + + + + + + template +=20=20=20 + _OutputIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, output_iterator_tag) + { + +=20=20=20=20=20 + + + + typename iterator_traits<_InputIterator>::value_type __value =3D *__= first; + __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred)) + __rebound_pred + =3D __gnu_cxx::__ops::__iter_comp_val(__binary_pred); + *__result =3D __value; + while (++__first !=3D __last) + if (!__rebound_pred(__first, __value)) + { + __value =3D *__first; + *++__result =3D __value; + } + return ++__result; + } + + + + + + + + template +=20=20=20 + _ForwardIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, forward_iterator_tag) + { + +=20=20=20=20=20 + + + *__result =3D *__first; + while (++__first !=3D __last) + if (!__binary_pred(__result, __first)) + *++__result =3D *__first; + return ++__result; + } + + + + + + + template +=20=20=20 + void + __reverse(_BidirectionalIterator __first, _BidirectionalIterator __las= t, + bidirectional_iterator_tag) + { + while (true) + if (__first =3D=3D __last || __first =3D=3D --__last) + return; + else + { + std::iter_swap(__first, __last); + ++__first; + } + } + + + + + + + template +=20=20=20 + void + __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + if (__first =3D=3D __last) + return; + --__last; + while (__first < __last) + { + std::iter_swap(__first, __last); + ++__first; + --__last; + } + } +# 1128 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) + { + +=20=20=20=20=20 + + ; + std::__reverse(__first, __last, std::__iterator_category(__first)); + } +# 1156 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _OutputIterator + reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __= last, + _OutputIterator __result) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + while (__first !=3D __last) + { + --__last; + *__result =3D *__last; + ++__result; + } + return __result; + } + + + + + + template +=20=20=20 + _EuclideanRingElement + __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) + { + while (__n !=3D 0) + { + _EuclideanRingElement __t =3D __m % __n; + __m =3D __n; + __n =3D __t; + } + return __m; + } + +inline namespace _V2 { + + + template +=20=20=20 + _ForwardIterator + __rotate(_ForwardIterator __first, + _ForwardIterator __middle, + _ForwardIterator __last, + forward_iterator_tag) + { + if (__first =3D=3D __middle) + return __last; + else if (__last =3D=3D __middle) + return __first; + + _ForwardIterator __first2 =3D __middle; + do + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first =3D=3D __middle) + __middle =3D __first2; + } + while (__first2 !=3D __last); + + _ForwardIterator __ret =3D __first; + + __first2 =3D __middle; + + while (__first2 !=3D __last) + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first =3D=3D __middle) + __middle =3D __first2; + else if (__first2 =3D=3D __last) + __first2 =3D __middle; + } + return __ret; + } + + + template +=20=20=20 + _BidirectionalIterator + __rotate(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + +=20=20=20=20=20 + + + if (__first =3D=3D __middle) + return __last; + else if (__last =3D=3D __middle) + return __first; + + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + + while (__first !=3D __middle && __middle !=3D __last) + { + std::iter_swap(__first, --__last); + ++__first; + } + + if (__first =3D=3D __middle) + { + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + return __last; + } + else + { + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + return __first; + } + } + + + template +=20=20=20 + _RandomAccessIterator + __rotate(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + random_access_iterator_tag) + { + +=20=20=20=20=20 + + + if (__first =3D=3D __middle) + return __last; + else if (__last =3D=3D __middle) + return __first; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_= type + _Distance; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + _Distance __n =3D __last - __first; + _Distance __k =3D __middle - __first; + + if (__k =3D=3D __n - __k) + { + std::swap_ranges(__first, __middle, __middle); + return __middle; + } + + _RandomAccessIterator __p =3D __first; + _RandomAccessIterator __ret =3D __first + (__last - __middle); + + for (;;) + { + if (__k < __n - __k) + { + if (__is_pod(_ValueType) && __k =3D=3D 1) + { + _ValueType __t =3D std::move(*__p); + std::move(__p + 1, __p + __n, __p); + *(__p + __n - 1) =3D std::move(__t); + return __ret; + } + _RandomAccessIterator __q =3D __p + __k; + for (_Distance __i =3D 0; __i < __n - __k; ++ __i) + { + std::iter_swap(__p, __q); + ++__p; + ++__q; + } + __n %=3D __k; + if (__n =3D=3D 0) + return __ret; + std::swap(__n, __k); + __k =3D __n - __k; + } + else + { + __k =3D __n - __k; + if (__is_pod(_ValueType) && __k =3D=3D 1) + { + _ValueType __t =3D std::move(*(__p + __n - 1)); + std::move_backward(__p, __p + __n - 1, __p + __n); + *__p =3D std::move(__t); + return __ret; + } + _RandomAccessIterator __q =3D __p + __n; + __p =3D __q - __k; + for (_Distance __i =3D 0; __i < __n - __k; ++ __i) + { + --__p; + --__q; + std::iter_swap(__p, __q); + } + __n %=3D __k; + if (__n =3D=3D 0) + return __ret; + std::swap(__n, __k); + } + } + } +# 1387 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + rotate(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last) + { + +=20=20=20=20=20 + + ; + ; + + return std::__rotate(__first, __middle, __last, + std::__iterator_category(__first)); + } + +} +# 1425 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); + } + + + template +=20=20=20 + _ForwardIterator + __partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, forward_iterator_tag) + { + if (__first =3D=3D __last) + return __first; + + while (__pred(*__first)) + if (++__first =3D=3D __last) + return __first; + + _ForwardIterator __next =3D __first; + + while (++__next !=3D __last) + if (__pred(*__next)) + { + std::iter_swap(__first, __next); + ++__first; + } + + return __first; + } + + + template +=20=20=20 + _BidirectionalIterator + __partition(_BidirectionalIterator __first, _BidirectionalIterator __l= ast, + _Predicate __pred, bidirectional_iterator_tag) + { + while (true) + { + while (true) + if (__first =3D=3D __last) + return __first; + else if (__pred(*__first)) + ++__first; + else + break; + --__last; + while (true) + if (__first =3D=3D __last) + return __first; + else if (!bool(__pred(*__last))) + --__last; + else + break; + std::iter_swap(__first, __last); + ++__first; + } + } +# 1506 "/usr/include/c++/13/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 =3D=3D 1) + return __first; + + if (__len <=3D __buffer_size) + { + _ForwardIterator __result1 =3D __first; + _Pointer __result2 =3D __buffer; + + + + + *__result2 =3D std::move(*__first); + ++__result2; + ++__first; + for (; __first !=3D __last; ++__first) + if (__pred(__first)) + { + *__result1 =3D std::move(*__first); + ++__result1; + } + else + { + *__result2 =3D std::move(*__first); + ++__result2; + } + + std::move(__buffer, __result2, __result1); + return __result1; + } + + _ForwardIterator __middle =3D __first; + std::advance(__middle, __len / 2); + _ForwardIterator __left_split =3D + std::__stable_partition_adaptive(__first, __middle, __pred, + __len / 2, __buffer, + __buffer_size); + + + + _Distance __right_len =3D __len - __len / 2; + _ForwardIterator __right_split =3D + std::__find_if_not_n(__middle, __right_len, __pred); + + if (__right_len) + __right_split =3D + 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 =3D std::__find_if_not(__first, __last, __pred); + + if (__first =3D=3D __last) + return __first; + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _Temporary_buffer<_ForwardIterator, _ValueType> + __buf(__first, std::distance(__first, __last)); + return + std::__stable_partition_adaptive(__first, __last, __pred, + _DistanceType(__buf.requested_size()), + __buf.begin(), + _DistanceType(__buf.size())); + } +# 1608 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline _ForwardIterator + stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__stable_partition(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + + + + + template +=20=20=20 + void + __heap_select(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp) + { + std::__make_heap(__first, __middle, __comp); + for (_RandomAccessIterator __i =3D __middle; __i < __last; ++__i) + if (__comp(__i, __first)) + std::__pop_heap(__first, __middle, __i, __comp); + } + + + + template +=20=20=20 + _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 =3D=3D __result_last) + return __result_last; + _RandomAccessIterator __result_real_last =3D __result_first; + while (__first !=3D __last && __result_real_last !=3D __result_last) + { + *__result_real_last =3D *__first; + ++__result_real_last; + ++__first; + } + + std::__make_heap(__result_first, __result_real_last, __comp); + while (__first !=3D __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; + } +# 1701 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last) + { +# 1716 "/usr/include/c++/13/bits/stl_algo.h" 3 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 1751 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { +# 1768 "/usr/include/c++/13/bits/stl_algo.h" 3 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template +=20=20=20 + void + __unguarded_linear_insert(_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val =3D std::move(*__last); + _RandomAccessIterator __next =3D __last; + --__next; + while (__comp(__val, __next)) + { + *__last =3D std::move(*__next); + __last =3D __next; + --__next; + } + *__last =3D std::move(__val); + } + + + template +=20=20=20 + void + __insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__first =3D=3D __last) return; + + for (_RandomAccessIterator __i =3D __first + 1; __i !=3D __last; ++_= _i) + { + if (__comp(__i, __first)) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val =3D std::move(*__i); + std::move_backward(__first, __i, __i + 1); + *__first =3D std::move(__val); + } + else + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + } + + + template +=20=20=20 + inline void + __unguarded_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + for (_RandomAccessIterator __i =3D __first; __i !=3D __last; ++__i) + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + + + + + enum { _S_threshold =3D 16 }; + + + template +=20=20=20 + 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 +=20=20=20 + _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 +=20=20=20 + inline _RandomAccessIterator + __unguarded_partition_pivot(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + _RandomAccessIterator __mid =3D __first + (__last - __first) / 2; + std::__move_median_to_first(__first, __first + 1, __mid, __last - 1, + __comp); + return std::__unguarded_partition(__first + 1, __last, __first, __co= mp); + } + + template +=20=20=20 + 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 +=20=20=20 + void + __introsort_loop(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Size __depth_limit, _Compare __comp) + { + while (__last - __first > int(_S_threshold)) + { + if (__depth_limit =3D=3D 0) + { + std::__partial_sort(__first, __last, __last, __comp); + return; + } + --__depth_limit; + _RandomAccessIterator __cut =3D + std::__unguarded_partition_pivot(__first, __last, __comp); + std::__introsort_loop(__cut, __last, __depth_limit, __comp); + __last =3D __cut; + } + } + + + + template +=20=20=20 + inline void + __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + if (__first !=3D __last) + { + std::__introsort_loop(__first, __last, + std::__lg(__last - __first) * 2, + __comp); + std::__final_insertion_sort(__first, __last, __comp); + } + } + + template +=20=20=20 + void + __introselect(_RandomAccessIterator __first, _RandomAccessIterator __n= th, + _RandomAccessIterator __last, _Size __depth_limit, + _Compare __comp) + { + while (__last - __first > 3) + { + if (__depth_limit =3D=3D 0) + { + std::__heap_select(__first, __nth + 1, __last, __comp); + + std::iter_swap(__first, __nth); + return; + } + --__depth_limit; + _RandomAccessIterator __cut =3D + std::__unguarded_partition_pivot(__first, __last, __comp); + if (__cut <=3D __nth) + __first =3D __cut; + else + __last =3D __cut; + } + std::__insertion_sort(__first, __last, __comp); + } +# 2002 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template +=20=20=20 + _ForwardIterator + __upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len =3D std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half =3D __len >> 1; + _ForwardIterator __middle =3D __first; + std::advance(__middle, __half); + if (__comp(__val, __middle)) + __len =3D __half; + else + { + __first =3D __middle; + ++__first; + __len =3D __len - __half - 1; + } + } + return __first; + } +# 2058 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_less_iter()); + } +# 2089 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + template +=20=20=20 + 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 =3D std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half =3D __len >> 1; + _ForwardIterator __middle =3D __first; + std::advance(__middle, __half); + if (__comp_it_val(__middle, __val)) + { + __first =3D __middle; + ++__first; + __len =3D __len - __half - 1; + } + else if (__comp_val_it(__val, __middle)) + __len =3D __half; + else + { + _ForwardIterator __left + =3D std::__lower_bound(__first, __middle, __val, __comp_it_val); + std::advance(__first, __len); + _ForwardIterator __right + =3D std::__upper_bound(++__middle, __first, __val, __comp_val_it); + return pair<_ForwardIterator, _ForwardIterator>(__left, __right); + } + } + return pair<_ForwardIterator, _ForwardIterator>(__first, __first); + } +# 2162 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val(), + __gnu_cxx::__ops::__val_less_iter()); + } +# 2199 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + ; +=20=20=20=20=20 + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp), + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } +# 2233 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + _ForwardIterator __i + =3D std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + return __i !=3D __last && !(__val < *__i); + } +# 2267 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + ; +=20=20=20=20=20 + ; + + _ForwardIterator __i + =3D std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + return __i !=3D __last && !bool(__comp(__val, *__i)); + } + + + + + template + void + __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last= 1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + { + if (__comp(__first2, __first1)) + { + *__result =3D std::move(*__first2); + ++__first2; + } + else + { + *__result =3D std::move(*__first1); + ++__first1; + } + ++__result; + } + if (__first1 !=3D __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 =3D=3D __last1) + { + std::move_backward(__first2, __last2, __result); + return; + } + else if (__first2 =3D=3D __last2) + return; + + --__last1; + --__last2; + while (true) + { + if (__comp(__last2, __last1)) + { + *--__result =3D std::move(*__last1); + if (__first1 =3D=3D __last1) + { + std::move_backward(__first2, ++__last2, __result); + return; + } + --__last1; + } + else + { + *--__result =3D std::move(*__last2); + if (__first2 =3D=3D __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 <=3D __buffer_size) + { + if (__len2) + { + __buffer_end =3D std::move(__middle, __last, __buffer); + std::move_backward(__first, __middle, __last); + return std::move(__buffer, __buffer_end, __first); + } + else + return __first; + } + else if (__len1 <=3D __buffer_size) + { + if (__len1) + { + __buffer_end =3D 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 <=3D __len2) + { + _Pointer __buffer_end =3D std::move(__first, __middle, __buffer); + std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, + __first, __comp); + } + else + { + _Pointer __buffer_end =3D 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 <=3D __buffer_size || __len2 <=3D __buffer_size) + std::__merge_adaptive(__first, __middle, __last, + __len1, __len2, __buffer, __comp); + else + { + _BidirectionalIterator __first_cut =3D __first; + _BidirectionalIterator __second_cut =3D __middle; + _Distance __len11 =3D 0; + _Distance __len22 =3D 0; + if (__len1 > __len2) + { + __len11 =3D __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + =3D std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 =3D std::distance(__middle, __second_cut); + } + else + { + __len22 =3D __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + =3D std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 =3D std::distance(__first, __first_cut); + } + + _BidirectionalIterator __new_middle + =3D 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 =3D=3D 0 || __len2 =3D=3D 0) + return; + + if (__len1 + __len2 =3D=3D 2) + { + if (__comp(__middle, __first)) + std::iter_swap(__first, __middle); + return; + } + + _BidirectionalIterator __first_cut =3D __first; + _BidirectionalIterator __second_cut =3D __middle; + _Distance __len11 =3D 0; + _Distance __len22 =3D 0; + if (__len1 > __len2) + { + __len11 =3D __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + =3D std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 =3D std::distance(__middle, __second_cut); + } + else + { + __len22 =3D __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + =3D std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 =3D std::distance(__first, __first_cut); + } + + _BidirectionalIterator __new_middle + =3D 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 =3D=3D __middle || __middle =3D=3D __last) + return; + + const _DistanceType __len1 =3D std::distance(__first, __middle); + const _DistanceType __len2 =3D std::distance(__middle, __last); + + + typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBu= f; + + + _TmpBuf __buf(__first, std::min(__len1, __len2)); + + if (__builtin_expect(__buf.size() =3D=3D __buf.requested_size(), tru= e)) + std::__merge_adaptive + (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp); + else if (__builtin_expect(__buf.begin() =3D=3D 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); + + + + + } +# 2582 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2623 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + ; + + 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 !=3D __last1 && __first2 !=3D __last2) + { + if (__comp(__first2, __first1)) + { + *__result =3D std::move(*__first2); + ++__first2; + } + else + { + *__result =3D std::move(*__first1); + ++__first1; + } + ++__result; + } + return std::move(__first2, __last2, std::move(__first1, __last1, __r= esult)) + + ; + } + + template + void + __merge_sort_loop(_RandomAccessIterator1 __first, + _RandomAccessIterator1 __last, + _RandomAccessIterator2 __result, _Distance __step_size, + _Compare __comp) + { + const _Distance __two_step =3D 2 * __step_size; + + while (__last - __first >=3D __two_step) + { + __result =3D std::__move_merge(__first, __first + __step_size, + __first + __step_size, + __first + __two_step, + __result, __comp); + __first +=3D __two_step; + } + __step_size =3D std::min(_Distance(__last - __first), __step_size); + + std::__move_merge(__first, __first + __step_size, + __first + __step_size, __last, __result, __comp); + } + + template +=20=20=20 + void + __chunk_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Distance __chunk_size, _Compare __comp) + { + while (__last - __first >=3D __chunk_size) + { + std::__insertion_sort(__first, __first + __chunk_size, __comp); + __first +=3D __chunk_size; + } + std::__insertion_sort(__first, __last, __comp); + } + + enum { _S_chunk_size =3D 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 =3D __last - __first; + const _Pointer __buffer_last =3D __buffer + __len; + + _Distance __step_size =3D _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 *=3D 2; + std::__merge_sort_loop(__buffer, __buffer_last, __first, + __step_size, __comp); + __step_size *=3D 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 =3D (__last - __first + 1) / 2; + const _RandomAccessIterator __middle =3D __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 =3D __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); + } +# 2809 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + bool + __includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + { + if (__comp(__first2, __first1)) + return false; + if (!__comp(__first1, __first2)) + ++__first2; + ++__first1; + } + + return __first2 =3D=3D __last2; + } +# 2847 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2892 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 2928 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + bool + __next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first =3D=3D __last) + return false; + _BidirectionalIterator __i =3D __first; + ++__i; + if (__i =3D=3D __last) + return false; + __i =3D __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii =3D __i; + --__i; + if (__comp(__i, __ii)) + { + _BidirectionalIterator __j =3D __last; + while (!__comp(__i, --__j)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i =3D=3D __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 2978 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 3011 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template +=20=20=20 + bool + __prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first =3D=3D __last) + return false; + _BidirectionalIterator __i =3D __first; + ++__i; + if (__i =3D=3D __last) + return false; + __i =3D __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii =3D __i; + --__i; + if (__comp(__ii, __i)) + { + _BidirectionalIterator __j =3D __last; + while (!__comp(--__j, __i)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i =3D=3D __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 3081 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3114 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template +=20=20=20 + _OutputIterator + __replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + for (; __first !=3D __last; ++__first, (void)++__result) + if (__pred(__first)) + *__result =3D __new_value; + else + *__result =3D *__first; + return __result; + } +# 3166 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + replace_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + const _Tp& __old_value, const _Tp& __new_value) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__old_value), + __new_value); + } +# 3201 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred), + __new_value); + } +# 3230 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last) + { return std::is_sorted_until(__first, __last) =3D=3D __last; } +# 3245 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { return std::is_sorted_until(__first, __last, __comp) =3D=3D __last; } + + template +=20=20=20 + _ForwardIterator + __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first =3D=3D __last) + return __last; + + _ForwardIterator __next =3D __first; + for (++__next; __next !=3D __last; __first =3D __next, (void)++__nex= t) + if (__comp(__next, __first)) + return __next; + return __next; + } +# 3276 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3301 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 3327 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair + minmax(const _Tp& __a, const _Tp& __b) + { + +=20=20=20=20=20 + + return __b < __a ? pair(__b, __a) + : pair(__a, __b); + } +# 3348 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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 =3D __first; + if (__first =3D=3D __last + || ++__next =3D=3D __last) + return std::make_pair(__first, __first); + + _ForwardIterator __min{}, __max{}; + if (__comp(__next, __first)) + { + __min =3D __next; + __max =3D __first; + } + else + { + __min =3D __first; + __max =3D __next; + } + + __first =3D __next; + ++__first; + + while (__first !=3D __last) + { + __next =3D __first; + if (++__next =3D=3D __last) + { + if (__comp(__first, __min)) + __min =3D __first; + else if (!__comp(__first, __max)) + __max =3D __first; + break; + } + + if (__comp(__next, __first)) + { + if (__comp(__next, __min)) + __min =3D __next; + if (!__comp(__first, __max)) + __max =3D __first; + } + else + { + if (__comp(__first, __min)) + __min =3D __first; + if (!__comp(__next, __max)) + __max =3D __next; + } + + __first =3D __next; + ++__first; + } + + return std::make_pair(__min, __max); + } +# 3428 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3456 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l) + { + ; + pair __p =3D + std::__minmax_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_less_iter()); + return std::make_pair(*__p.first, *__p.second); + } + + template + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l, _Compare __comp) + { + ; + pair __p =3D + std::__minmax_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::make_pair(*__p.first, *__p.second); + } +# 3512 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__pred)); + } + + + template +=20=20=20 + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __pred) + { + using _Cat1 + =3D typename iterator_traits<_ForwardIterator1>::iterator_category; + using _Cat2 + =3D typename iterator_traits<_ForwardIterator2>::iterator_category; + using _It1_is_RA =3D is_same<_Cat1, random_access_iterator_tag>; + using _It2_is_RA =3D is_same<_Cat2, random_access_iterator_tag>; + constexpr bool __ra_iters =3D _It1_is_RA() && _It2_is_RA(); + if (__ra_iters) + { + auto __d1 =3D std::distance(__first1, __last1); + auto __d2 =3D std::distance(__first2, __last2); + if (__d1 !=3D __d2) + return false; + } + + + + for (; __first1 !=3D __last1 && __first2 !=3D __last2; + ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__ra_iters) + { + if (__first1 =3D=3D __last1) + return true; + } + else + { + auto __d1 =3D std::distance(__first1, __last1); + auto __d2 =3D std::distance(__first2, __last2); + if (__d1 =3D=3D 0 && __d2 =3D=3D 0) + return true; + if (__d1 !=3D __d2) + return false; + } + + for (_ForwardIterator1 __scan =3D __first1; __scan !=3D __last1; ++_= _scan) + { + if (__scan !=3D std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches =3D std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 =3D=3D __matches + || std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + !=3D __matches) + return false; + } + return true; + } +# 3607 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + 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()); + } +# 3635 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + 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)); + } +# 3665 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr const _Tp& + clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi) + { + do { if (std::__is_constant_evaluated() && !bool(!(__hi < __lo))) __= builtin_unreachable(); } while (false); + return std::min(std::max(__val, __lo), __hi); + } +# 3685 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr const _Tp& + clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __c= omp) + { + do { if (std::__is_constant_evaluated() && !bool(!__comp(__hi, __lo)= )) __builtin_unreachable(); } while (false); + return std::min(std::max(__val, __lo, __comp), __hi, __comp); + } +# 3717 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + pair<_IntType, _IntType> + __gen_two_uniform_ints(_IntType __b0, _IntType __b1, + _UniformRandomBitGenerator&& __g) + { + _IntType __x + =3D uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g); + return std::make_pair(__x / __b1, __x % __b1); + } +# 3739 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + void + shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, + _UniformRandomNumberGenerator&& __g) + { + +=20=20=20=20=20 + + ; + + if (__first =3D=3D __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_ty= pe; + typedef typename __distr_type::param_type __p_type; + + typedef typename remove_reference<_UniformRandomNumberGenerator>::ty= pe + _Gen; + typedef typename common_type:= :type + __uc_type; + + const __uc_type __urngrange =3D __g.max() - __g.min(); + const __uc_type __urange =3D __uc_type(__last - __first); + + if (__urngrange / __urange >=3D __urange) + + { + _RandomAccessIterator __i =3D __first + 1; + + + + + + if ((__urange % 2) =3D=3D 0) + { + __distr_type __d{0, 1}; + std::iter_swap(__i++, __first + __d(__g)); + } + + + + + + while (__i !=3D __last) + { + const __uc_type __swap_range =3D __uc_type(__i - __first) + 1; + + const pair<__uc_type, __uc_type> __pospos =3D + __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 =3D __first + 1; __i !=3D __last; ++_= _i) + std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first))); + } + + + + + +# 3824 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _Function + for_each(_InputIterator __first, _InputIterator __last, _Function __f) + { + +=20=20=20=20=20 + ; + for (; __first !=3D __last; ++__first) + __f(*__first); + return __f; + } +# 3850 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _InputIterator + for_each_n(_InputIterator __first, _Size __n, _Function __f) + { + auto __n2 =3D std::__size_to_integer(__n); + using _Cat =3D typename iterator_traits<_InputIterator>::iterator_ca= tegory; + if constexpr (is_base_of_v) + { + if (__n2 <=3D 0) + return __first; + auto __last =3D __first + __n2; + std::for_each(__first, __last, std::move(__f)); + return __last; + } + else + { + while (__n2-->0) + { + __f(*__first); + ++__first; + } + return __first; + } + } +# 3886 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 3911 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _InputIterator + find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 3943 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + for (; __first1 !=3D __last1; ++__first1) + for (_ForwardIterator __iter =3D __first2; __iter !=3D __last2; ++__iter) + if (*__first1 =3D=3D *__iter) + return __first1; + return __last1; + } +# 3984 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2, + _BinaryPredicate __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + for (; __first1 !=3D __last1; ++__first1) + for (_ForwardIterator __iter =3D __first2; __iter !=3D __last2; ++__iter) + if (__comp(*__first1, *__iter)) + return __first1; + return __last1; + } +# 4017 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 4043 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } +# 4069 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline typename iterator_traits<_InputIterator>::difference_type + count(_InputIterator __first, _InputIterator __last, const _Tp& __valu= e) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 4093 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline typename iterator_traits<_InputIterator>::difference_type + count_if(_InputIterator __first, _InputIterator __last, _Predicate __p= red) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 4134 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 4174 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } +# 4210 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 4244 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val, + _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); + } +# 4270 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + search(_ForwardIterator __first, _ForwardIterator __last, + const _Searcher& __searcher) + { return __searcher(__first, __last).first; } +# 4294 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _OutputIterator + transform(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + for (; __first !=3D __last; ++__first, (void)++__result) + *__result =3D __unary_op(*__first); + return __result; + } +# 4332 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _OutputIterator + transform(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _OutputIterator __result, + _BinaryOperation __binary_op) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + + for (; __first1 !=3D __last1; ++__first1, (void)++__first2, ++__resu= lt) + *__result =3D __binary_op(*__first1, *__first2); + return __result; + } +# 4366 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + void + replace(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __old_value, const _Tp& __new_value) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + for (; __first !=3D __last; ++__first) + if (*__first =3D=3D __old_value) + *__first =3D __new_value; + } +# 4399 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + void + replace_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, const _Tp& __new_value) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + for (; __first !=3D __last; ++__first) + if (__pred(*__first)) + *__first =3D __new_value; + } +# 4431 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + void + generate(_ForwardIterator __first, _ForwardIterator __last, + _Generator __gen) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + for (; __first !=3D __last; ++__first) + *__first =3D __gen(); + } +# 4464 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + _OutputIterator + generate_n(_OutputIterator __first, _Size __n, _Generator __gen) + { + +=20=20=20=20=20 + + + + typedef __decltype(std::__size_to_integer(__n)) _IntSize; + for (_IntSize __niter =3D std::__size_to_integer(__n); + __niter > 0; --__niter, (void) ++__first) + *__first =3D __gen(); + return __first; + } +# 4499 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + if (__first =3D=3D __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)); + } +# 4539 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _BinaryPredicate __binary_pred) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + + if (__first =3D=3D __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)); + } +# 4578 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + inline void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __= last) + { + +=20=20=20=20=20 + + ; + + if (__first !=3D __last) + for (_RandomAccessIterator __i =3D __first + 1; __i !=3D __last; ++__i) + { + + _RandomAccessIterator __j =3D __first + + std::rand() % ((__i - __first) + 1); + if (__i !=3D __j) + std::iter_swap(__i, __j); + } + } +# 4617 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __= last, + + _RandomNumberGenerator&& __rand) + + + + { + +=20=20=20=20=20 + + ; + + if (__first =3D=3D __last) + return; + for (_RandomAccessIterator __i =3D __first + 1; __i !=3D __last; ++_= _i) + { + _RandomAccessIterator __j =3D __first + __rand((__i - __first) + 1); + if (__i !=3D __j) + std::iter_swap(__i, __j); + } + } +# 4659 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _ForwardIterator + partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + + return std::__partition(__first, __last, __pred, + std::__iterator_category(__first)); + } +# 4694 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4733 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4770 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + ; + + if (__first =3D=3D __last || __nth =3D=3D __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4810 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + ; + + if (__first =3D=3D __last || __nth =3D=3D __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4848 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 4879 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__co= mp)); + } + + template +=20=20=20 + _OutputIterator + __merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + { + if (__comp(__first2, __first1)) + { + *__result =3D *__first2; + ++__first2; + } + else + { + *__result =3D *__first1; + ++__first1; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 4942 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4993 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + inline void + __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __l= ast, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_= type + _DistanceType; + + if (__first =3D=3D __last) + return; + + + typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; + + + _TmpBuf __buf(__first, (__last - __first + 1) / 2); + + if (__builtin_expect(__buf.requested_size() =3D=3D __buf.size(), tru= e)) + std::__stable_sort_adaptive(__first, + __first + _DistanceType(__buf.size()), + __last, __buf.begin(), __comp); + else if (__builtin_expect(__buf.begin() =3D=3D 0, false)) + std::__inplace_stable_sort(__first, __last, __comp); + else + std::__stable_sort_adaptive_resize(__first, __last, __buf.begin(), + _DistanceType(__buf.size()), __comp); + + + + } +# 5071 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __las= t) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5105 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __las= t, + _Compare __comp) + { + +=20=20=20=20=20 + +=20=20=20=20=20 + + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template +=20=20=20 + _OutputIterator + __set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + { + if (__comp(__first1, __first2)) + { + *__result =3D *__first1; + ++__first1; + } + else if (__comp(__first2, __first1)) + { + *__result =3D *__first2; + ++__first2; + } + else + { + *__result =3D *__first1; + ++__first1; + ++__first2; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 5175 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5226 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template +=20=20=20 + _OutputIterator + __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + if (__comp(__first1, __first2)) + ++__first1; + else if (__comp(__first2, __first1)) + ++__first2; + else + { + *__result =3D *__first1; + ++__first1; + ++__first2; + ++__result; + } + return __result; + } +# 5299 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5349 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template +=20=20=20 + _OutputIterator + __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + if (__comp(__first1, __first2)) + { + *__result =3D *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + ++__first2; + else + { + ++__first1; + ++__first2; + } + return std::copy(__first1, __last1, __result); + } +# 5424 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5476 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template +=20=20=20 + _OutputIterator + __set_symmetric_difference(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + while (__first1 !=3D __last1 && __first2 !=3D __last2) + if (__comp(__first1, __first2)) + { + *__result =3D *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + { + *__result =3D *__first2; + ++__first2; + ++__result; + } + else + { + ++__first1; + ++__first2; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 5557 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __l= ast1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + return std::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5609 "/usr/include/c++/13/bits/stl_algo.h" 3 + template +=20=20=20 + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __l= ast1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 +=20=20=20=20=20 + +=20=20=20=20=20 + +=20=20=20=20=20 + + +=20=20=20=20=20 + + + ; + ; + ; + ; + + 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 =3D=3D __last) + return __first; + _ForwardIterator __result =3D __first; + while (++__first !=3D __last) + if (__comp(__first, __result)) + __result =3D __first; + return __result; + } +# 5663 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + _ForwardIterator + inline min_element(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5688 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + 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 =3D=3D __last) return __first; + _ForwardIterator __result =3D __first; + while (++__first !=3D __last) + if (__comp(__result, __first)) + __result =3D __first; + return __result; + } +# 5727 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + ; + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5752 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + +=20=20=20=20=20 +=20=20=20=20=20 + + + ; + ; + + 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 =3D uniform_int_distribution<_Size>; + using __param_type =3D typename __distrib_type::param_type; + __distrib_type __d{}; + _Size __sample_sz =3D 0; + while (__first !=3D __last && __sample_sz !=3D __n) + { + __out[__sample_sz++] =3D *__first; + ++__first; + } + for (auto __pop_sz =3D __sample_sz; __first !=3D __last; + ++__first, (void) ++__pop_sz) + { + const auto __k =3D __d(__g, __param_type{0, __pop_sz}); + if (__k < __n) + __out[__k] =3D *__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 =3D uniform_int_distribution<_Size>; + using __param_type =3D typename __distrib_type::param_type; + using _USize =3D make_unsigned_t<_Size>; + using _Gen =3D remove_reference_t<_UniformRandomBitGenerator>; + using __uc_type =3D common_type_t; + + if (__first =3D=3D __last) + return __out; + + __distrib_type __d{}; + _Size __unsampled_sz =3D std::distance(__first, __last); + __n =3D std::min(__n, __unsampled_sz); + + + + + const __uc_type __urngrange =3D __g.max() - __g.min(); + if (__urngrange / __uc_type(__unsampled_sz) >=3D __uc_type(__unsampl= ed_sz)) + + + { + while (__n !=3D 0 && __unsampled_sz >=3D 2) + { + const pair<_Size, _Size> __p =3D + __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g); + + --__unsampled_sz; + if (__p.first < __n) + { + *__out++ =3D *__first; + --__n; + } + + ++__first; + + if (__n =3D=3D 0) break; + + --__unsampled_sz; + if (__p.second < __n) + { + *__out++ =3D *__first; + --__n; + } + + ++__first; + } + } + + + + for (; __n !=3D 0; ++__first) + if (__d(__g, __param_type{0, --__unsampled_sz}) < __n) + { + *__out++ =3D *__first; + --__n; + } + return __out; + } + + + + + template + _SampleIterator + sample(_PopulationIterator __first, _PopulationIterator __last, + _SampleIterator __out, _Distance __n, + _UniformRandomBitGenerator&& __g) + { + using __pop_cat =3D typename + std::iterator_traits<_PopulationIterator>::iterator_category; + using __samp_cat =3D 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 = =3D __n; + return std:: + __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d, + std::forward<_UniformRandomBitGenerator>(__g)); + } + + + + + +} +# 68 "/usr/include/c++/13/functional" 2 3 +# 79 "/usr/include/c++/13/functional" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template struct _Placeholder { }; +# 108 "/usr/include/c++/13/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)...); + } +# 141 "/usr/include/c++/13/functional" 3 + template::value> + class _Mem_fn_base + : public _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using _Traits =3D _Mem_fn_traits<_MemFunPtr>; + + using _Arity =3D typename _Traits::__arity; + using _Varargs =3D typename _Traits::__vararg; + + template + friend struct _Bind_check_arity; + + _MemFunPtr _M_pmf; + + public: + + using result_type =3D 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 =3D integral_constant; + using _Varargs =3D 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; + }; +# 234 "/usr/include/c++/13/functional" 3 + template +=20=20=20 + inline _Mem_fn<_Tp _Class::*> + mem_fn(_Tp _Class::* __pm) noexcept + { + return _Mem_fn<_Tp _Class::*>(__pm); + } +# 253 "/usr/include/c++/13/functional" 3 + template + struct is_bind_expression + : public false_type { }; +# 265 "/usr/include/c++/13/functional" 3 + template + struct is_placeholder + : public integral_constant + { }; + + + template inline constexpr bool is_bind_expression_v + =3D is_bind_expression<_Tp>::value; + template inline constexpr int is_placeholder_v + =3D is_placeholder<_Tp>::value; + + + + + + + + namespace placeholders + { +# 294 "/usr/include/c++/13/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 + =3D typename enable_if<(__i < tuple_size<_Tuple>::value), + tuple_element<__i, _Tuple>>::type::type; +# 362 "/usr/include/c++/13/functional" 3 + template::value, + bool _IsPlaceholder =3D (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)); } +# 487 "/usr/include/c++/13/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 =3D decltype( + _Mu::type>()( + std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) ); + + template + using _Res_type_impl + =3D typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type; + + template + using _Res_type =3D _Res_type_impl<_Functor, _CallArgs, _Bound_args...>; + + template + using __dependent =3D typename + enable_if::value+1), _Functor>::type; + + template class __cv_quals> + using _Res_type_cv =3D _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&) =3D default; + _Bind(_Bind&&) =3D 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&) =3D default; + _Bind_result(_Bind_result&&) =3D 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()); + } + + + + + }; +# 764 "/usr/include/c++/13/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) =3D=3D sizeof...(_Args), + "Wrong number of arguments for function"); + }; + + template + struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...> + { + static_assert(sizeof...(_BoundArgs) >=3D sizeof...(_Args), + "Wrong number of arguments for function"); + }; + + template + struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...> + { + using _Arity =3D typename _Mem_fn<_Tp _Class::*>::_Arity; + using _Varargs =3D typename _Mem_fn<_Tp _Class::*>::_Varargs; + static_assert(_Varargs::value + ? sizeof...(_BoundArgs) >=3D _Arity::value + 1 + : sizeof...(_BoundArgs) =3D=3D _Arity::value + 1, + "Wrong number of arguments for pointer-to-member"); + }; + + + + + template::type> + using __is_socketlike =3D __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)...); + } +# 1084 "/usr/include/c++/13/functional" 3 + template + class _Not_fn + { + template + using __inv_res_t =3D 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) =3D default; + _Not_fn(_Not_fn&& __fn) =3D default; + ~_Not_fn() =3D default; +# 1118 "/usr/include/c++/13/functional" 3 + template decltype(_S_not<__inv_res_t<_Fn &, _Args= ...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_F= n &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) = { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(_= _args)...); } + template 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 decltype(_S_not<__inv_res_t<_Fn &&, _Arg= s...>>()) 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<_Ar= gs>(__args)...); } + template decltype(_S_not<__inv_res_t<_Fn const &&= , _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothro= w_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)...); } + + + 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 { }; +# 1165 "/usr/include/c++/13/functional" 3 + template +=20=20=20 + inline auto + not_fn(_Fn&& __fn) + noexcept(std::is_nothrow_constructible, _Fn&&>::valu= e) + { + return _Not_fn>{std::forward<_Fn>(__fn), 0}; + } + + + + template> + class default_searcher + { + public: +=20=20=20=20=20 + default_searcher(_ForwardIterator1 __pat_first, + _ForwardIterator1 __pat_last, + _BinaryPredicate __pred =3D _BinaryPredicate()) + : _M_m(__pat_first, __pat_last, std::move(__pred)) + { } + + template + + pair<_ForwardIterator2, _ForwardIterator2> + operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const + { + _ForwardIterator2 __first_ret =3D + std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m), + std::get<2>(_M_m)); + auto __ret =3D std::make_pair(__first_ret, __first_ret); + if (__ret.first !=3D __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 =3D 0; __i < __patlen - 1; ++__i) + _M_bad_char[__pat[__i]] =3D __patlen - 1 - __i; + } + + using __diff_type =3D _Tp; + + __diff_type + _M_lookup(_Key __key, __diff_type __not_found) const + { + auto __iter =3D _M_bad_char.find(__key); + if (__iter =3D=3D _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 =3D 0; __i < __patlen - 1; ++__i) + { + auto __ch =3D __pat[__i]; + using _UCh =3D make_unsigned_t; + auto __uch =3D static_cast<_UCh>(__ch); + std::get<0>(_M_bad_char)[__uch] =3D __patlen - 1 - __i; + } + } + + using __diff_type =3D _Tp; + + template + __diff_type + _M_lookup(_Key __key, __diff_type __not_found) const + { + auto __ukey =3D static_cast>(__key); + if (__ukey >=3D _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 =3D typename iterator_traits<_RAIter>::difference_type> + using __boyer_moore_base_t + =3D __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 =3D equal_to<>> + class boyer_moore_searcher + : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> + { + using _Base =3D __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicat= e>; + using typename _Base::__diff_type; + + public: + boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, + _Hash __hf =3D _Hash(), + _BinaryPredicate __pred =3D _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 =3D this->_M_pred(); + __diff_type __suffixlen =3D __len - __pos; + for (__diff_type __i =3D 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 =3D this->_M_pred(); + __diff_type __i =3D 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 =3D equal_to<>> + class boyer_moore_horspool_searcher + : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> + { + using _Base =3D __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicat= e>; + using typename _Base::__diff_type; + + public: + boyer_moore_horspool_searcher(_RAIter __pat, + _RAIter __pat_end, + _Hash __hf =3D _Hash(), + _BinaryPredicate __pred + =3D _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 =3D this->_M_pred(); + auto __patlen =3D _M_pat_end - _M_pat; + if (__patlen =3D=3D 0) + return std::make_pair(__first, __first); + auto __len =3D __last - __first; + while (__len >=3D __patlen) + { + for (auto __scan =3D __patlen - 1; + __pred(__first[__scan], _M_pat[__scan]); --__scan) + if (__scan =3D=3D 0) + return std::make_pair(__first, __first + __patlen); + auto __shift =3D _M_bad_char_shift(__first[__patlen - 1]); + __len -=3D __shift; + __first +=3D __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 - __p= at) + { + auto __patlen =3D __pat_end - __pat; + if (__patlen =3D=3D 0) + return; + __diff_type __last_prefix =3D __patlen - 1; + for (__diff_type __p =3D __patlen - 1; __p >=3D 0; --__p) + { + if (_M_is_prefix(__pat, __patlen, __p + 1)) + __last_prefix =3D __p + 1; + _M_good_suffix[__p] =3D __last_prefix + (__patlen - 1 - __p); + } + for (__diff_type __p =3D 0; __p < __patlen - 1; ++__p) + { + auto __slen =3D _M_suffix_length(__pat, __patlen, __p); + auto __pos =3D __patlen - 1 - __slen; + if (!__pred(__pat[__p - __slen], __pat[__pos])) + _M_good_suffix[__pos] =3D __patlen - 1 - __p + __slen; + } + } + + template + template + pair<_RandomAccessIterator2, _RandomAccessIterator2> + boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: + operator()(_RandomAccessIterator2 __first, + _RandomAccessIterator2 __last) const + { + auto __patlen =3D _M_pat_end - _M_pat; + if (__patlen =3D=3D 0) + return std::make_pair(__first, __first); + const auto& __pred =3D this->_M_pred(); + __diff_type __i =3D __patlen - 1; + auto __stringlen =3D __last - __first; + while (__i < __stringlen) + { + __diff_type __j =3D __patlen - 1; + while (__j >=3D 0 && __pred(__first[__i], _M_pat[__j])) + { + --__i; + --__j; + } + if (__j < 0) + { + const auto __match =3D __first + __i + 1; + return std::make_pair(__match, __match + __patlen); + } + __i +=3D std::max(_M_bad_char_shift(__first[__i]), + _M_good_suffix[__j]); + } + return std::make_pair(__last, __last); + } + + + + + + + +} +# 105 "/usr/include/gtest/gtest-printers.h" 2 3 4 +# 114 "/usr/include/gtest/gtest-printers.h" 3 4 +# 1 "/usr/include/gtest/internal/gtest-internal.h" 1 3 4 +# 45 "/usr/include/gtest/internal/gtest-internal.h" 3 4 +# 1 "/usr/include/c++/13/stdlib.h" 1 3 4 +# 46 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 + +# 1 "/usr/include/riscv64-linux-gnu/sys/wait.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +extern "C" { +# 36 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +# 1 "/usr/include/signal.h" 1 3 4 +# 27 "/usr/include/signal.h" 3 4 +extern "C" { + + +# 1 "/usr/include/riscv64-linux-gnu/bits/signum-generic.h" 1 3 4 +# 76 "/usr/include/riscv64-linux-gnu/bits/signum-generic.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/signum-arch.h" 1 3 4 +# 77 "/usr/include/riscv64-linux-gnu/bits/signum-generic.h" 2 3 4 +# 31 "/usr/include/signal.h" 2 3 4 + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/sig_atomic_t.h" 1 3 4 + + + + + + + +typedef __sig_atomic_t sig_atomic_t; +# 33 "/usr/include/signal.h" 2 3 4 +# 57 "/usr/include/signal.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 1 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 +# 5 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/__sigval_t.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/types/__sigval_t.h" 3 4 +union sigval +{ + int sival_int; + void *sival_ptr; +}; + +typedef union sigval __sigval_t; +# 7 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 +# 16 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/siginfo-arch.h" 1 3 4 +# 17 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 +# 36 "/usr/include/riscv64-linux-gnu/bits/types/siginfo_t.h" 3 4 +typedef struct + { + int si_signo; + + int si_errno; + + int si_code; + + + + + + int __pad0; + + + union + { + int _pad[((128 / sizeof (int)) - 4)]; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + } _kill; + + + struct + { + int si_tid; + int si_overrun; + __sigval_t si_sigval; + } _timer; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + __sigval_t si_sigval; + } _rt; + + + struct + { + __pid_t si_pid; + __uid_t si_uid; + int si_status; + __clock_t si_utime; + __clock_t si_stime; + } _sigchld; + + + struct + { + void *si_addr; +=20=20=20=20 + short int si_addr_lsb; + union + { + + struct + { + void *_lower; + void *_upper; + } _addr_bnd; + + __uint32_t _pkey; + } _bounds; + } _sigfault; + + + struct + { + long int si_band; + int si_fd; + } _sigpoll; + + + + struct + { + void *_call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; + + } _sifields; + } siginfo_t ; +# 58 "/usr/include/signal.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/siginfo-consts.h" 1 3 4 +# 35 "/usr/include/riscv64-linux-gnu/bits/siginfo-consts.h" 3 4 +enum +{ + SI_ASYNCNL =3D -60, + SI_DETHREAD =3D -7, + + SI_TKILL, + SI_SIGIO, + + SI_ASYNCIO, + SI_MESGQ, + SI_TIMER, + + + + + + SI_QUEUE, + SI_USER, + SI_KERNEL =3D 0x80 +# 66 "/usr/include/riscv64-linux-gnu/bits/siginfo-consts.h" 3 4 +}; + + + + +enum +{ + ILL_ILLOPC =3D 1, + + ILL_ILLOPN, + + ILL_ILLADR, + + ILL_ILLTRP, + + ILL_PRVOPC, + + ILL_PRVREG, + + ILL_COPROC, + + ILL_BADSTK, + + ILL_BADIADDR + +}; + + +enum +{ + FPE_INTDIV =3D 1, + + FPE_INTOVF, + + FPE_FLTDIV, + + FPE_FLTOVF, + + FPE_FLTUND, + + FPE_FLTRES, + + FPE_FLTINV, + + FPE_FLTSUB, + + FPE_FLTUNK =3D 14, + + FPE_CONDTRAP + +}; + + +enum +{ + SEGV_MAPERR =3D 1, + + SEGV_ACCERR, + + SEGV_BNDERR, + + SEGV_PKUERR, + + SEGV_ACCADI, + + SEGV_ADIDERR, + + SEGV_ADIPERR, + + SEGV_MTEAERR, + + SEGV_MTESERR + +}; + + +enum +{ + BUS_ADRALN =3D 1, + + BUS_ADRERR, + + BUS_OBJERR, + + BUS_MCEERR_AR, + + BUS_MCEERR_AO + +}; + + + + +enum +{ + TRAP_BRKPT =3D 1, + + TRAP_TRACE, + + TRAP_BRANCH, + + TRAP_HWBKPT, + + TRAP_UNK + +}; + + + + +enum +{ + CLD_EXITED =3D 1, + + CLD_KILLED, + + CLD_DUMPED, + + CLD_TRAPPED, + + CLD_STOPPED, + + CLD_CONTINUED + +}; + + +enum +{ + POLL_IN =3D 1, + + POLL_OUT, + + POLL_MSG, + + POLL_ERR, + + POLL_PRI, + + POLL_HUP + +}; + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/siginfo-consts-arch.h" 1 3 4 +# 214 "/usr/include/riscv64-linux-gnu/bits/siginfo-consts.h" 2 3 4 +# 59 "/usr/include/signal.h" 2 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/sigval_t.h" 1 3 4 +# 16 "/usr/include/riscv64-linux-gnu/bits/types/sigval_t.h" 3 4 +typedef __sigval_t sigval_t; +# 63 "/usr/include/signal.h" 2 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/sigevent_t.h" 1 3 4 + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/wordsize.h" 1 3 4 +# 5 "/usr/include/riscv64-linux-gnu/bits/types/sigevent_t.h" 2 3 4 +# 22 "/usr/include/riscv64-linux-gnu/bits/types/sigevent_t.h" 3 4 +typedef struct sigevent + { + __sigval_t sigev_value; + int sigev_signo; + int sigev_notify; + + union + { + int _pad[((64 / sizeof (int)) - 4)]; + + + + __pid_t _tid; + + struct + { + void (*_function) (__sigval_t); + pthread_attr_t *_attribute; + } _sigev_thread; + } _sigev_un; + } sigevent_t; +# 67 "/usr/include/signal.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/sigevent-consts.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/sigevent-consts.h" 3 4 +enum +{ + SIGEV_SIGNAL =3D 0, + + SIGEV_NONE, + + SIGEV_THREAD, + + + SIGEV_THREAD_ID =3D 4 + + +}; +# 68 "/usr/include/signal.h" 2 3 4 + + + + +typedef void (*__sighandler_t) (int); + + + + +extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler) + noexcept (true); + +extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler) + noexcept (true); + + + + + + +extern __sighandler_t signal (int __sig, __sighandler_t __handler) + noexcept (true); +# 112 "/usr/include/signal.h" 3 4 +extern int kill (__pid_t __pid, int __sig) noexcept (true); + + + + + + +extern int killpg (__pid_t __pgrp, int __sig) noexcept (true); + + + +extern int raise (int __sig) noexcept (true); + + + +extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) + noexcept (true); +extern int gsignal (int __sig) noexcept (true); + + + + +extern void psignal (int __sig, const char *__s); + + +extern void psiginfo (const siginfo_t *__pinfo, const char *__s); +# 151 "/usr/include/signal.h" 3 4 +extern int sigpause (int __sig) __asm__ ("__xpg_sigpause") + __attribute__ ((__deprecated__ ("Use the sigsuspend function instead"))); +# 173 "/usr/include/signal.h" 3 4 +extern int sigblock (int __mask) noexcept (true) __attribute__ ((__depreca= ted__)); + + +extern int sigsetmask (int __mask) noexcept (true) __attribute__ ((__depre= cated__)); + + +extern int siggetmask (void) noexcept (true) __attribute__ ((__deprecated_= _)); +# 188 "/usr/include/signal.h" 3 4 +typedef __sighandler_t sighandler_t; + + + + +typedef __sighandler_t sig_t; + + + + + +extern int sigemptyset (sigset_t *__set) noexcept (true) __attribute__ ((_= _nonnull__ (1))); + + +extern int sigfillset (sigset_t *__set) noexcept (true) __attribute__ ((__= nonnull__ (1))); + + +extern int sigaddset (sigset_t *__set, int __signo) noexcept (true) __attr= ibute__ ((__nonnull__ (1))); + + +extern int sigdelset (sigset_t *__set, int __signo) noexcept (true) __attr= ibute__ ((__nonnull__ (1))); + + +extern int sigismember (const sigset_t *__set, int __signo) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int sigisemptyset (const sigset_t *__set) noexcept (true) __attribu= te__ ((__nonnull__ (1))); + + +extern int sigandset (sigset_t *__set, const sigset_t *__left, + const sigset_t *__right) noexcept (true) __attribute__ ((__nonnull= __ (1, 2, 3))); + + +extern int sigorset (sigset_t *__set, const sigset_t *__left, + const sigset_t *__right) noexcept (true) __attribute__ ((__nonnull_= _ (1, 2, 3))); + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/sigaction.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/sigaction.h" 3 4 +struct sigaction + { + + + union + { + + __sighandler_t sa_handler; + + void (*sa_sigaction) (int, siginfo_t *, void *); + } + __sigaction_handler; + + + + + + + + __sigset_t sa_mask; + + + int sa_flags; + + + void (*sa_restorer) (void); + }; +# 230 "/usr/include/signal.h" 2 3 4 + + +extern int sigprocmask (int __how, const sigset_t *__restrict __set, + sigset_t *__restrict __oset) noexcept (true); + + + + + + +extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ = (1))); + + +extern int sigaction (int __sig, const struct sigaction *__restrict __act, + struct sigaction *__restrict __oact) noexcept (true); + + +extern int sigpending (sigset_t *__set) noexcept (true) __attribute__ ((__= nonnull__ (1))); + + + + + + + +extern int sigwait (const sigset_t *__restrict __set, int *__restrict __si= g) + __attribute__ ((__nonnull__ (1, 2))); + + + + + + + +extern int sigwaitinfo (const sigset_t *__restrict __set, + siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int sigtimedwait (const sigset_t *__restrict __set, + siginfo_t *__restrict __info, + const struct timespec *__restrict __timeout) + __attribute__ ((__nonnull__ (1))); +# 292 "/usr/include/signal.h" 3 4 +extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val) + noexcept (true); + + + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/sigcontext.h" 1 3 4 +# 25 "/usr/include/riscv64-linux-gnu/bits/sigcontext.h" 3 4 +struct sigcontext { + + unsigned long int gregs[32]; + unsigned long long int fpregs[66] __attribute__ ((__aligned__ (16))); +}; +# 302 "/usr/include/signal.h" 2 3 4 + + +extern int sigreturn (struct sigcontext *__scp) noexcept (true); + + + + + + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 312 "/usr/include/signal.h" 2 3 4 + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/stack_t.h" 1 3 4 +# 23 "/usr/include/riscv64-linux-gnu/bits/types/stack_t.h" 3 4 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 24 "/usr/include/riscv64-linux-gnu/bits/types/stack_t.h" 2 3 4 + + +typedef struct + { + void *ss_sp; + int ss_flags; + size_t ss_size; + } stack_t; +# 314 "/usr/include/signal.h" 2 3 4 + + +# 1 "/usr/include/riscv64-linux-gnu/sys/ucontext.h" 1 3 4 +# 29 "/usr/include/riscv64-linux-gnu/sys/ucontext.h" 3 4 +typedef unsigned long int __riscv_mc_gp_state[32]; +# 44 "/usr/include/riscv64-linux-gnu/sys/ucontext.h" 3 4 +typedef unsigned long int greg_t; + + +typedef __riscv_mc_gp_state gregset_t; + + +typedef union __riscv_mc_fp_state fpregset_t; + + +struct __riscv_mc_f_ext_state + { + unsigned int __f[32]; + unsigned int __fcsr; + }; + +struct __riscv_mc_d_ext_state + { + unsigned long long int __f[32]; + unsigned int __fcsr; + }; + +struct __riscv_mc_q_ext_state + { + unsigned long long int __f[64] __attribute__ ((__aligned__ (16))); + unsigned int __fcsr; + + + unsigned int __glibc_reserved[3]; + }; + +union __riscv_mc_fp_state + { + struct __riscv_mc_f_ext_state __f; + struct __riscv_mc_d_ext_state __d; + struct __riscv_mc_q_ext_state __q; + }; + +typedef struct mcontext_t + { + __riscv_mc_gp_state __gregs; + union __riscv_mc_fp_state __fpregs; + } mcontext_t; + + +typedef struct ucontext_t + { + unsigned long int __uc_flags; + struct ucontext_t *uc_link; + stack_t uc_stack; + sigset_t uc_sigmask; + + + + + char __glibc_reserved[1024 / 8 - sizeof (sigset_t)]; +# 107 "/usr/include/riscv64-linux-gnu/sys/ucontext.h" 3 4 + mcontext_t uc_mcontext; + } ucontext_t; +# 317 "/usr/include/signal.h" 2 3 4 + + + + + + + +extern int siginterrupt (int __sig, int __interrupt) noexcept (true) + __attribute__ ((__deprecated__ ("Use sigaction with SA_RESTART instead")= )); + +# 1 "/usr/include/riscv64-linux-gnu/bits/sigstack.h" 1 3 4 +# 328 "/usr/include/signal.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/sigstksz.h" 1 3 4 +# 329 "/usr/include/signal.h" 2 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/ss_flags.h" 1 3 4 +# 27 "/usr/include/riscv64-linux-gnu/bits/ss_flags.h" 3 4 +enum +{ + SS_ONSTACK =3D 1, + + SS_DISABLE + +}; +# 330 "/usr/include/signal.h" 2 3 4 + + + +extern int sigaltstack (const stack_t *__restrict __ss, + stack_t *__restrict __oss) noexcept (true); + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/types/struct_sigstack.h" 1 3 4 +# 23 "/usr/include/riscv64-linux-gnu/bits/types/struct_sigstack.h" 3 4 +struct sigstack + { + void *ss_sp; + int ss_onstack; + }; +# 340 "/usr/include/signal.h" 2 3 4 + + + + + + + +extern int sigstack (struct sigstack *__ss, struct sigstack *__oss) + noexcept (true) __attribute__ ((__deprecated__)); + + + + + + +extern int sighold (int __sig) noexcept (true) + __attribute__ ((__deprecated__ ("Use the sigprocmask function instead"))= ); + + +extern int sigrelse (int __sig) noexcept (true) + __attribute__ ((__deprecated__ ("Use the sigprocmask function instead"))= ); + + +extern int sigignore (int __sig) noexcept (true) + __attribute__ ((__deprecated__ ("Use the signal function instead"))); + + +extern __sighandler_t sigset (int __sig, __sighandler_t __disp) noexcept (= true) + __attribute__ ((__deprecated__ ("Use the signal and sigprocmask function= s instead"))) + ; + + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/sigthread.h" 1 3 4 +# 31 "/usr/include/riscv64-linux-gnu/bits/sigthread.h" 3 4 +extern int pthread_sigmask (int __how, + const __sigset_t *__restrict __newmask, + __sigset_t *__restrict __oldmask)noexcept (true); + + +extern int pthread_kill (pthread_t __threadid, int __signo) noexcept (true= ); + + + +extern int pthread_sigqueue (pthread_t __threadid, int __signo, + const union sigval __value) noexcept (true); +# 377 "/usr/include/signal.h" 2 3 4 + + + + + + +extern int __libc_current_sigrtmin (void) noexcept (true); + +extern int __libc_current_sigrtmax (void) noexcept (true); + + + + + +# 1 "/usr/include/riscv64-linux-gnu/bits/signal_ext.h" 1 3 4 +# 29 "/usr/include/riscv64-linux-gnu/bits/signal_ext.h" 3 4 +extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal); +# 392 "/usr/include/signal.h" 2 3 4 + +} +# 37 "/usr/include/riscv64-linux-gnu/sys/wait.h" 2 3 4 +# 74 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +# 1 "/usr/include/riscv64-linux-gnu/bits/types/idtype_t.h" 1 3 4 + + + + +typedef enum +{ + P_ALL, + P_PID, + P_PGID, + P_PIDFD, + +} idtype_t; +# 75 "/usr/include/riscv64-linux-gnu/sys/wait.h" 2 3 4 +# 83 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +extern __pid_t wait (int *__stat_loc); +# 106 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options); +# 127 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop, + int __options); + + + + + + +struct rusage; + + + + + + + +extern __pid_t wait3 (int *__stat_loc, int __options, + struct rusage * __usage) noexcept (true); +# 159 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options, + struct rusage *__usage) noexcept (true); +# 173 "/usr/include/riscv64-linux-gnu/sys/wait.h" 3 4 +} +# 48 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 +# 56 "/usr/include/gtest/internal/gtest-internal.h" 3 4 +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/float.h" 1 3 4 +# 57 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 + + + +# 1 "/usr/include/c++/13/iomanip" 1 3 4 +# 36 "/usr/include/c++/13/iomanip" 3 4 +=20=20=20=20=20=20=20 +# 37 "/usr/include/c++/13/iomanip" 3 +# 47 "/usr/include/c++/13/iomanip" 3 +# 1 "/usr/include/c++/13/bits/quoted_string.h" 1 3 +# 33 "/usr/include/c++/13/bits/quoted_string.h" 3 +=20=20=20=20=20=20=20 +# 34 "/usr/include/c++/13/bits/quoted_string.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail { + + + + template + struct _Quoted_string + { + static_assert(is_reference<_String>::value + || is_pointer<_String>::value, + "String type must be pointer or reference"); + + _Quoted_string(_String __str, _CharT __del, _CharT __esc) + : _M_string(__str), _M_delim{__del}, _M_escape{__esc} + { } + + _Quoted_string& + operator=3D(_Quoted_string&) =3D delete; + + _String _M_string; + _CharT _M_delim; + _CharT _M_escape; + }; + + + template + struct _Quoted_string, _CharT> + { + _Quoted_string(basic_string_view<_CharT, _Traits> __str, + _CharT __del, _CharT __esc) + : _M_string(__str), _M_delim{__del}, _M_escape{__esc} + { } + + _Quoted_string& + operator=3D(_Quoted_string&) =3D delete; + + basic_string_view<_CharT, _Traits> _M_string; + _CharT _M_delim; + _CharT _M_escape; + }; +# 91 "/usr/include/c++/13/bits/quoted_string.h" 3 + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const _Quoted_string& __str) + { + std::basic_ostringstream<_CharT, _Traits> __ostr; + __ostr << __str._M_delim; + for (const _CharT* __c =3D __str._M_string; *__c; ++__c) + { + if (*__c =3D=3D __str._M_delim || *__c =3D=3D __str._M_escape) + __ostr << __str._M_escape; + __ostr << *__c; + } + __ostr << __str._M_delim; + + return __os << __ostr.str(); + } + + + + + + + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const _Quoted_string<_String, _CharT>& __str) + { + std::basic_ostringstream<_CharT, _Traits> __ostr; + __ostr << __str._M_delim; + for (auto __c : __str._M_string) + { + if (__c =3D=3D __str._M_delim || __c =3D=3D __str._M_escape) + __ostr << __str._M_escape; + __ostr << __c; + } + __ostr << __str._M_delim; + + return __os << __ostr.str(); + } + + + + + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + const _Quoted_string&, + _CharT>& __str) + { + _CharT __c; + __is >> __c; + if (!__is.good()) + return __is; + if (__c !=3D __str._M_delim) + { + __is.unget(); + __is >> __str._M_string; + return __is; + } + __str._M_string.clear(); + std::ios_base::fmtflags __flags + =3D __is.flags(__is.flags() & ~std::ios_base::skipws); + do + { + __is >> __c; + if (!__is.good()) + break; + if (__c =3D=3D __str._M_escape) + { + __is >> __c; + if (!__is.good()) + break; + } + else if (__c =3D=3D __str._M_delim) + break; + __str._M_string +=3D __c; + } + while (true); + __is.setf(__flags); + + return __is; + } + } + + +} +# 48 "/usr/include/c++/13/iomanip" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + struct _Resetiosflags { ios_base::fmtflags _M_mask; }; +# 67 "/usr/include/c++/13/iomanip" 3 + inline _Resetiosflags + resetiosflags(ios_base::fmtflags __mask) + { return { __mask }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) + { + __is.setf(ios_base::fmtflags(0), __f._M_mask); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f) + { + __os.setf(ios_base::fmtflags(0), __f._M_mask); + return __os; + } + + + struct _Setiosflags { ios_base::fmtflags _M_mask; }; +# 97 "/usr/include/c++/13/iomanip" 3 + inline _Setiosflags + setiosflags(ios_base::fmtflags __mask) + { return { __mask }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) + { + __is.setf(__f._M_mask); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) + { + __os.setf(__f._M_mask); + return __os; + } + + + struct _Setbase { int _M_base; }; +# 128 "/usr/include/c++/13/iomanip" 3 + inline _Setbase + setbase(int __base) + { return { __base }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f) + { + __is.setf(__f._M_base =3D=3D 8 ? ios_base::oct : + __f._M_base =3D=3D 10 ? ios_base::dec : + __f._M_base =3D=3D 16 ? ios_base::hex : + ios_base::fmtflags(0), ios_base::basefield); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f) + { + __os.setf(__f._M_base =3D=3D 8 ? ios_base::oct : + __f._M_base =3D=3D 10 ? ios_base::dec : + __f._M_base =3D=3D 16 ? ios_base::hex : + ios_base::fmtflags(0), ios_base::basefield); + return __os; + } + + + template + struct _Setfill { _CharT _M_c; }; +# 165 "/usr/include/c++/13/iomanip" 3 + template + inline _Setfill<_CharT> + setfill(_CharT __c) + { return { __c }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) + { + __is.fill(__f._M_c); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f) + { + __os.fill(__f._M_c); + return __os; + } + + + struct _Setprecision { int _M_n; }; +# 196 "/usr/include/c++/13/iomanip" 3 + inline _Setprecision + setprecision(int __n) + { return { __n }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) + { + __is.precision(__f._M_n); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) + { + __os.precision(__f._M_n); + return __os; + } + + + struct _Setw { int _M_n; }; +# 226 "/usr/include/c++/13/iomanip" 3 + inline _Setw + setw(int __n) + { return { __n }; } + + template + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) + { + __is.width(__f._M_n); + return __is; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) + { + __os.width(__f._M_n); + return __os; + } + + + + template + struct _Get_money { _MoneyT& _M_mon; bool _M_intl; }; +# 259 "/usr/include/c++/13/iomanip" 3 + template + inline _Get_money<_MoneyT> + get_money(_MoneyT& __mon, bool __intl =3D false) + { return { __mon, __intl }; } + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> _= _f) + { + typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + typedef istreambuf_iterator<_CharT, _Traits> _Iter; + typedef money_get<_CharT, _Iter> _MoneyGet; + + const _MoneyGet& __mg =3D use_facet<_MoneyGet>(__is.getloc()); + __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl, + __is, __err, __f._M_mon); + } + if (false) + { + __is._M_setstate(ios_base::badbit); + ; + } + if (false) + { __is._M_setstate(ios_base::badbit); } + if (__err) + __is.setstate(__err); + } + return __is; + } + + + template + struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; }; +# 306 "/usr/include/c++/13/iomanip" 3 + template + inline _Put_money<_MoneyT> + put_money(const _MoneyT& __mon, bool __intl =3D false) + { return { __mon, __intl }; } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> _= _f) + { + typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + typedef ostreambuf_iterator<_CharT, _Traits> _Iter; + typedef money_put<_CharT, _Iter> _MoneyPut; + + const _MoneyPut& __mp =3D use_facet<_MoneyPut>(__os.getloc()); + if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os, + __os.fill(), __f._M_mon).failed()) + __err |=3D ios_base::badbit; + } + if (false) + { + __os._M_setstate(ios_base::badbit); + ; + } + if (false) + { __os._M_setstate(ios_base::badbit); } + if (__err) + __os.setstate(__err); + } + return __os; + } + + template + struct _Put_time + { + const std::tm* _M_tmb; + const _CharT* _M_fmt; + }; +# 358 "/usr/include/c++/13/iomanip" 3 + template + inline _Put_time<_CharT> + put_time(const std::tm* __tmb, const _CharT* __fmt) + { return { __tmb, __fmt }; } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f) + { + typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + typedef ostreambuf_iterator<_CharT, _Traits> _Iter; + typedef time_put<_CharT, _Iter> _TimePut; + + const _CharT* const __fmt_end =3D __f._M_fmt + + _Traits::length(__f._M_fmt); + + const _TimePut& __mp =3D use_facet<_TimePut>(__os.getloc()); + if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(), + __f._M_tmb, __f._M_fmt, __fmt_end).failed()) + __err |=3D ios_base::badbit; + } + if (false) + { + __os._M_setstate(ios_base::badbit); + ; + } + if (false) + { __os._M_setstate(ios_base::badbit); } + if (__err) + __os.setstate(__err); + } + return __os; + } + + template + struct _Get_time + { + std::tm* _M_tmb; + const _CharT* _M_fmt; + }; +# 413 "/usr/include/c++/13/iomanip" 3 + template + inline _Get_time<_CharT> + get_time(std::tm* __tmb, const _CharT* __fmt) + { return { __tmb, __fmt }; } + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f) + { + typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false); + if (__cerb) + { + ios_base::iostate __err =3D ios_base::goodbit; + if (true) + { + typedef istreambuf_iterator<_CharT, _Traits> _Iter; + typedef time_get<_CharT, _Iter> _TimeGet; + + const _CharT* const __fmt_end =3D __f._M_fmt + + _Traits::length(__f._M_fmt); + + const _TimeGet& __mg =3D use_facet<_TimeGet>(__is.getloc()); + __mg.get(_Iter(__is.rdbuf()), _Iter(), __is, + __err, __f._M_tmb, __f._M_fmt, __fmt_end); + } + if (false) + { + __is._M_setstate(ios_base::badbit); + ; + } + if (false) + { __is._M_setstate(ios_base::badbit); } + if (__err) + __is.setstate(__err); + } + return __is; + } +# 461 "/usr/include/c++/13/iomanip" 3 + template + inline auto + quoted(const _CharT* __string, + _CharT __delim =3D _CharT('"'), _CharT __escape =3D _CharT('\\')) + { + return __detail::_Quoted_string(__string, __d= elim, + __escape); + } + + template + inline auto + quoted(const basic_string<_CharT, _Traits, _Alloc>& __string, + _CharT __delim =3D _CharT('"'), _CharT __escape =3D _CharT('\\')) + { + return __detail::_Quoted_string< + const basic_string<_CharT, _Traits, _Alloc>&, _CharT>( + __string, __delim, __escape); + } + + template + inline auto + quoted(basic_string<_CharT, _Traits, _Alloc>& __string, + _CharT __delim =3D _CharT('"'), _CharT __escape =3D _CharT('\\')) + { + return __detail::_Quoted_string< + basic_string<_CharT, _Traits, _Alloc>&, _CharT>( + __string, __delim, __escape); + } + + + + + template + inline auto + quoted(basic_string_view<_CharT, _Traits> __sv, + _CharT __delim =3D _CharT('"'), _CharT __escape =3D _CharT('\\')) + { + return __detail::_Quoted_string< + basic_string_view<_CharT, _Traits>, _CharT>(__sv, __delim, __escape); + } +# 510 "/usr/include/c++/13/iomanip" 3 + extern template ostream& operator<<(ostream&, _Setfill); + extern template ostream& operator<<(ostream&, _Setiosflags); + extern template ostream& operator<<(ostream&, _Resetiosflags); + extern template ostream& operator<<(ostream&, _Setbase); + extern template ostream& operator<<(ostream&, _Setprecision); + extern template ostream& operator<<(ostream&, _Setw); + extern template istream& operator>>(istream&, _Setfill); + extern template istream& operator>>(istream&, _Setiosflags); + extern template istream& operator>>(istream&, _Resetiosflags); + extern template istream& operator>>(istream&, _Setbase); + extern template istream& operator>>(istream&, _Setprecision); + extern template istream& operator>>(istream&, _Setw); + + + extern template wostream& operator<<(wostream&, _Setfill); + extern template wostream& operator<<(wostream&, _Setiosflags); + extern template wostream& operator<<(wostream&, _Resetiosflags); + extern template wostream& operator<<(wostream&, _Setbase); + extern template wostream& operator<<(wostream&, _Setprecision); + extern template wostream& operator<<(wostream&, _Setw); + extern template wistream& operator>>(wistream&, _Setfill); + extern template wistream& operator>>(wistream&, _Setiosflags); + extern template wistream& operator>>(wistream&, _Resetiosflags); + extern template wistream& operator>>(wistream&, _Setbase); + extern template wistream& operator>>(wistream&, _Setprecision); + extern template wistream& operator>>(wistream&, _Setw); + + + + +} +# 61 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 + +# 1 "/usr/include/c++/13/map" 1 3 4 +# 58 "/usr/include/c++/13/map" 3 4 +=20=20=20=20=20=20=20 +# 59 "/usr/include/c++/13/map" 3 + + + +# 1 "/usr/include/c++/13/bits/stl_tree.h" 1 3 +# 61 "/usr/include/c++/13/bits/stl_tree.h" 3 +=20=20=20=20=20=20=20 +# 62 "/usr/include/c++/13/bits/stl_tree.h" 3 +# 75 "/usr/include/c++/13/bits/stl_tree.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 99 "/usr/include/c++/13/bits/stl_tree.h" 3 + enum _Rb_tree_color { _S_red =3D false, _S_black =3D true }; + + struct _Rb_tree_node_base + { + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + + _Rb_tree_color _M_color; + _Base_ptr _M_parent; + _Base_ptr _M_left; + _Base_ptr _M_right; + + static _Base_ptr + _S_minimum(_Base_ptr __x) noexcept + { + while (__x->_M_left !=3D 0) __x =3D __x->_M_left; + return __x; + } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) noexcept + { + while (__x->_M_left !=3D 0) __x =3D __x->_M_left; + return __x; + } + + static _Base_ptr + _S_maximum(_Base_ptr __x) noexcept + { + while (__x->_M_right !=3D 0) __x =3D __x->_M_right; + return __x; + } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) noexcept + { + while (__x->_M_right !=3D 0) __x =3D __x->_M_right; + return __x; + } + }; + + + template + struct _Rb_tree_key_compare + { + _Key_compare _M_key_compare; + + _Rb_tree_key_compare() + noexcept(is_nothrow_default_constructible<_Key_compare>::value) + + : _M_key_compare() + { } + + _Rb_tree_key_compare(const _Key_compare& __comp) + : _M_key_compare(__comp) + { } + + + + _Rb_tree_key_compare(const _Rb_tree_key_compare&) =3D default; + + _Rb_tree_key_compare(_Rb_tree_key_compare&& __x) + noexcept(is_nothrow_copy_constructible<_Key_compare>::value) + : _M_key_compare(__x._M_key_compare) + { } + + }; + + + struct _Rb_tree_header + { + _Rb_tree_node_base _M_header; + size_t _M_node_count; + + _Rb_tree_header() noexcept + { + _M_header._M_color =3D _S_red; + _M_reset(); + } + + + _Rb_tree_header(_Rb_tree_header&& __x) noexcept + { + if (__x._M_header._M_parent !=3D nullptr) + _M_move_data(__x); + else + { + _M_header._M_color =3D _S_red; + _M_reset(); + } + } + + + void + _M_move_data(_Rb_tree_header& __from) + { + _M_header._M_color =3D __from._M_header._M_color; + _M_header._M_parent =3D __from._M_header._M_parent; + _M_header._M_left =3D __from._M_header._M_left; + _M_header._M_right =3D __from._M_header._M_right; + _M_header._M_parent->_M_parent =3D &_M_header; + _M_node_count =3D __from._M_node_count; + + __from._M_reset(); + } + + void + _M_reset() + { + _M_header._M_parent =3D 0; + _M_header._M_left =3D &_M_header; + _M_header._M_right =3D &_M_header; + _M_node_count =3D 0; + } + }; + + template + struct _Rb_tree_node : public _Rb_tree_node_base + { + typedef _Rb_tree_node<_Val>* _Link_type; +# 231 "/usr/include/c++/13/bits/stl_tree.h" 3 + __gnu_cxx::__aligned_membuf<_Val> _M_storage; + + _Val* + _M_valptr() + { return _M_storage._M_ptr(); } + + const _Val* + _M_valptr() const + { return _M_storage._M_ptr(); } + + }; + + __attribute__ ((__pure__)) _Rb_tree_node_base* + _Rb_tree_increment(_Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) const _Rb_tree_node_base* + _Rb_tree_increment(const _Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) _Rb_tree_node_base* + _Rb_tree_decrement(_Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) const _Rb_tree_node_base* + _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw (); + + template + struct _Rb_tree_iterator + { + typedef _Tp value_type; + typedef _Tp& reference; + typedef _Tp* pointer; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; + typedef _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_iterator() noexcept + : _M_node() { } + + explicit + _Rb_tree_iterator(_Base_ptr __x) noexcept + : _M_node(__x) { } + + reference + operator*() const noexcept + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const noexcept + { return static_cast<_Link_type> (_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node =3D _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp =3D *this; + _M_node =3D _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() noexcept + { + _M_node =3D _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) noexcept + { + _Self __tmp =3D *this; + _M_node =3D _Rb_tree_decrement(_M_node); + return __tmp; + } + + friend bool + operator=3D=3D(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node =3D=3D __y._M_node; } + + + friend bool + operator!=3D(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node !=3D __y._M_node; } + + + _Base_ptr _M_node; + }; + + template + struct _Rb_tree_const_iterator + { + typedef _Tp value_type; + typedef const _Tp& reference; + typedef const _Tp* pointer; + + typedef _Rb_tree_iterator<_Tp> iterator; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_const_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; + typedef const _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_const_iterator() noexcept + : _M_node() { } + + explicit + _Rb_tree_const_iterator(_Base_ptr __x) noexcept + : _M_node(__x) { } + + _Rb_tree_const_iterator(const iterator& __it) noexcept + : _M_node(__it._M_node) { } + + iterator + _M_const_cast() const noexcept + { return iterator(const_cast(_M_node))= ; } + + reference + operator*() const noexcept + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const noexcept + { return static_cast<_Link_type>(_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node =3D _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp =3D *this; + _M_node =3D _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() noexcept + { + _M_node =3D _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) noexcept + { + _Self __tmp =3D *this; + _M_node =3D _Rb_tree_decrement(_M_node); + return __tmp; + } + + friend bool + operator=3D=3D(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node =3D=3D __y._M_node; } + + + friend bool + operator!=3D(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node !=3D __y._M_node; } + + + _Base_ptr _M_node; + }; + + __attribute__((__nonnull__)) + void + _Rb_tree_insert_and_rebalance(const bool __insert_left, + _Rb_tree_node_base* __x, + _Rb_tree_node_base* __p, + _Rb_tree_node_base& __header) throw (); + + __attribute__((__nonnull__,__returns_nonnull__)) + _Rb_tree_node_base* + _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, + _Rb_tree_node_base& __header) throw (); + + + template + struct _Rb_tree_merge_helper { }; + + + template > + class _Rb_tree + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Rb_tree_node<_Val> >::other _Node_allocator; + + typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits; + + protected: + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + typedef _Rb_tree_node<_Val>* _Link_type; + typedef const _Rb_tree_node<_Val>* _Const_Link_type; + + private: + + + struct _Reuse_or_alloc_node + { + _Reuse_or_alloc_node(_Rb_tree& __t) + : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t) + { + if (_M_root) + { + _M_root->_M_parent =3D 0; + + if (_M_nodes->_M_left) + _M_nodes =3D _M_nodes->_M_left; + } + else + _M_nodes =3D 0; + } + + + _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) =3D delete; + + + ~_Reuse_or_alloc_node() + { _M_t._M_erase(static_cast<_Link_type>(_M_root)); } + + template + _Link_type + operator()(_Arg&& __arg) + { + _Link_type __node =3D static_cast<_Link_type>(_M_extract()); + if (__node) + { + _M_t._M_destroy_node(__node); + _M_t._M_construct_node(__node, std::forward<_Arg>(__arg)); + return __node; + } + + return _M_t._M_create_node(std::forward<_Arg>(__arg)); + } + + private: + _Base_ptr + _M_extract() + { + if (!_M_nodes) + return _M_nodes; + + _Base_ptr __node =3D _M_nodes; + _M_nodes =3D _M_nodes->_M_parent; + if (_M_nodes) + { + if (_M_nodes->_M_right =3D=3D __node) + { + _M_nodes->_M_right =3D 0; + + if (_M_nodes->_M_left) + { + _M_nodes =3D _M_nodes->_M_left; + + while (_M_nodes->_M_right) + _M_nodes =3D _M_nodes->_M_right; + + if (_M_nodes->_M_left) + _M_nodes =3D _M_nodes->_M_left; + } + } + else + _M_nodes->_M_left =3D 0; + } + else + _M_root =3D 0; + + return __node; + } + + _Base_ptr _M_root; + _Base_ptr _M_nodes; + _Rb_tree& _M_t; + }; + + + + struct _Alloc_node + { + _Alloc_node(_Rb_tree& __t) + : _M_t(__t) { } + + template + _Link_type + operator()(_Arg&& __arg) const + { return _M_t._M_create_node(std::forward<_Arg>(__arg)); } + + private: + _Rb_tree& _M_t; + }; + + public: + typedef _Key key_type; + typedef _Val value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + _Node_allocator& + _M_get_Node_allocator() noexcept + { return this->_M_impl; } + + const _Node_allocator& + _M_get_Node_allocator() const noexcept + { return this->_M_impl; } + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Node_allocator()); } + + protected: + _Link_type + _M_get_node() + { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); } + + void + _M_put_node(_Link_type __p) noexcept + { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } +# 590 "/usr/include/c++/13/bits/stl_tree.h" 3 + template + void + _M_construct_node(_Link_type __node, _Args&&... __args) + { + if (true) + { + ::new(__node) _Rb_tree_node<_Val>; + _Alloc_traits::construct(_M_get_Node_allocator(), + __node->_M_valptr(), + std::forward<_Args>(__args)...); + } + if (false) + { + __node->~_Rb_tree_node<_Val>(); + _M_put_node(__node); + ; + } + } + + template + _Link_type + _M_create_node(_Args&&... __args) + { + _Link_type __tmp =3D _M_get_node(); + _M_construct_node(__tmp, std::forward<_Args>(__args)...); + return __tmp; + } + + + void + _M_destroy_node(_Link_type __p) noexcept + { + + + + _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr()); + __p->~_Rb_tree_node<_Val>(); + + } + + void + _M_drop_node(_Link_type __p) noexcept + { + _M_destroy_node(__p); + _M_put_node(__p); + } + + template + _Link_type + _M_clone_node(_Link_type __x, _NodeGen& __node_gen) + { + + using _Vp =3D __conditional_t<_MoveValue, + value_type&&, + const value_type&>; + + _Link_type __tmp + =3D __node_gen(std::forward<_Vp>(*__x->_M_valptr())); + __tmp->_M_color =3D __x->_M_color; + __tmp->_M_left =3D 0; + __tmp->_M_right =3D 0; + return __tmp; + } + + protected: + + + + + template + + struct _Rb_tree_impl + : public _Node_allocator + , public _Rb_tree_key_compare<_Key_compare> + , public _Rb_tree_header + { + typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare; + + _Rb_tree_impl() + noexcept(is_nothrow_default_constructible<_Node_allocator>::value && = is_nothrow_default_constructible<_Base_key_compare>::value) + + + : _Node_allocator() + { } + + _Rb_tree_impl(const _Rb_tree_impl& __x) + : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x)) + , _Base_key_compare(__x._M_key_compare) + , _Rb_tree_header() + { } + + + + + + + _Rb_tree_impl(_Rb_tree_impl&&) + noexcept( is_nothrow_move_constructible<_Base_key_compare>::value ) + =3D default; + + explicit + _Rb_tree_impl(_Node_allocator&& __a) + : _Node_allocator(std::move(__a)) + { } + + _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a) + : _Node_allocator(std::move(__a)), + _Base_key_compare(std::move(__x)), + _Rb_tree_header(std::move(__x)) + { } + + _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a) + : _Node_allocator(std::move(__a)), _Base_key_compare(__comp) + { } + + }; + + _Rb_tree_impl<_Compare> _M_impl; + + protected: + _Base_ptr& + _M_root() noexcept + { return this->_M_impl._M_header._M_parent; } + + _Const_Base_ptr + _M_root() const noexcept + { return this->_M_impl._M_header._M_parent; } + + _Base_ptr& + _M_leftmost() noexcept + { return this->_M_impl._M_header._M_left; } + + _Const_Base_ptr + _M_leftmost() const noexcept + { return this->_M_impl._M_header._M_left; } + + _Base_ptr& + _M_rightmost() noexcept + { return this->_M_impl._M_header._M_right; } + + _Const_Base_ptr + _M_rightmost() const noexcept + { return this->_M_impl._M_header._M_right; } + + _Link_type + _M_mbegin() const noexcept + { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent);= } + + _Link_type + _M_begin() noexcept + { return _M_mbegin(); } + + _Const_Link_type + _M_begin() const noexcept + { + return static_cast<_Const_Link_type> + (this->_M_impl._M_header._M_parent); + } + + _Base_ptr + _M_end() noexcept + { return &this->_M_impl._M_header; } + + _Const_Base_ptr + _M_end() const noexcept + { return &this->_M_impl._M_header; } + + static const _Key& + _S_key(_Const_Link_type __x) + { + + + + static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{}, + "comparison object must be invocable " + "with two arguments of key type"); + + + + if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{}) + static_assert( + is_invocable_v, + "comparison object must be invocable as const"); + + + + return _KeyOfValue()(*__x->_M_valptr()); + } + + static _Link_type + _S_left(_Base_ptr __x) noexcept + { return static_cast<_Link_type>(__x->_M_left); } + + static _Const_Link_type + _S_left(_Const_Base_ptr __x) noexcept + { return static_cast<_Const_Link_type>(__x->_M_left); } + + static _Link_type + _S_right(_Base_ptr __x) noexcept + { return static_cast<_Link_type>(__x->_M_right); } + + static _Const_Link_type + _S_right(_Const_Base_ptr __x) noexcept + { return static_cast<_Const_Link_type>(__x->_M_right); } + + static const _Key& + _S_key(_Const_Base_ptr __x) + { return _S_key(static_cast<_Const_Link_type>(__x)); } + + static _Base_ptr + _S_minimum(_Base_ptr __x) noexcept + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) noexcept + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Base_ptr + _S_maximum(_Base_ptr __x) noexcept + { return _Rb_tree_node_base::_S_maximum(__x); } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) noexcept + { return _Rb_tree_node_base::_S_maximum(__x); } + + public: + typedef _Rb_tree_iterator iterator; + typedef _Rb_tree_const_iterator const_iterator; + + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + + using node_type =3D _Node_handle<_Key, _Val, _Node_allocator>; + using insert_return_type =3D _Node_insert_return< + __conditional_t, const_iterator, iterator>, + node_type>; + + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_unique_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_equal_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_unique_pos(const_iterator __pos, + const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_equal_pos(const_iterator __pos, + const key_type& __k); + + private: + + template + iterator + _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&); + + iterator + _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z); + + template + iterator + _M_insert_lower(_Base_ptr __y, _Arg&& __v); + + template + iterator + _M_insert_equal_lower(_Arg&& __x); + + iterator + _M_insert_lower_node(_Base_ptr __p, _Link_type __z); + + iterator + _M_insert_equal_lower_node(_Link_type __z); +# 881 "/usr/include/c++/13/bits/stl_tree.h" 3 + enum { __as_lvalue, __as_rvalue }; + + template + _Link_type + _M_copy(_Link_type, _Base_ptr, _NodeGen&); + + template + _Link_type + _M_copy(const _Rb_tree& __x, _NodeGen& __gen) + { + _Link_type __root =3D + _M_copy<_MoveValues>(__x._M_mbegin(), _M_end(), __gen); + _M_leftmost() =3D _S_minimum(__root); + _M_rightmost() =3D _S_maximum(__root); + _M_impl._M_node_count =3D __x._M_impl._M_node_count; + return __root; + } + + _Link_type + _M_copy(const _Rb_tree& __x) + { + _Alloc_node __an(*this); + return _M_copy<__as_lvalue>(__x, __an); + } + + void + _M_erase(_Link_type __x); + + iterator + _M_lower_bound(_Link_type __x, _Base_ptr __y, + const _Key& __k); + + const_iterator + _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y, + const _Key& __k) const; + + iterator + _M_upper_bound(_Link_type __x, _Base_ptr __y, + const _Key& __k); + + const_iterator + _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y, + const _Key& __k) const; + + public: + + + + + _Rb_tree() =3D default; + + + _Rb_tree(const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_impl(__comp, _Node_allocator(__a)) { } + + _Rb_tree(const _Rb_tree& __x) + : _M_impl(__x._M_impl) + { + if (__x._M_root() !=3D 0) + _M_root() =3D _M_copy(__x); + } + + + _Rb_tree(const allocator_type& __a) + : _M_impl(_Node_allocator(__a)) + { } + + _Rb_tree(const _Rb_tree& __x, const allocator_type& __a) + : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a)) + { + if (__x._M_root() !=3D nullptr) + _M_root() =3D _M_copy(__x); + } + + _Rb_tree(_Rb_tree&&) =3D default; + + _Rb_tree(_Rb_tree&& __x, const allocator_type& __a) + : _Rb_tree(std::move(__x), _Node_allocator(__a)) + { } + + private: + _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type) + noexcept(is_nothrow_default_constructible<_Compare>::value) + : _M_impl(std::move(__x._M_impl), std::move(__a)) + { } + + _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type) + : _M_impl(__x._M_impl._M_key_compare, std::move(__a)) + { + if (__x._M_root() !=3D nullptr) + _M_move_data(__x, false_type{}); + } + + public: + _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a) + noexcept( noexcept( + _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(), + std::declval())) ) + : _Rb_tree(std::move(__x), std::move(__a), + typename _Alloc_traits::is_always_equal{}) + { } + + + ~_Rb_tree() noexcept + { _M_erase(_M_begin()); } + + _Rb_tree& + operator=3D(const _Rb_tree& __x); + + + _Compare + key_comp() const + { return _M_impl._M_key_compare; } + + iterator + begin() noexcept + { return iterator(this->_M_impl._M_header._M_left); } + + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_header._M_left); } + + iterator + end() noexcept + { return iterator(&this->_M_impl._M_header); } + + const_iterator + end() const noexcept + { return const_iterator(&this->_M_impl._M_header); } + + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_impl._M_node_count =3D=3D 0; } + + size_type + size() const noexcept + { return _M_impl._M_node_count; } + + size_type + max_size() const noexcept + { return _Alloc_traits::max_size(_M_get_Node_allocator()); } + + void + swap(_Rb_tree& __t) + noexcept(__is_nothrow_swappable<_Compare>::value); + + + + template + pair + _M_insert_unique(_Arg&& __x); + + template + iterator + _M_insert_equal(_Arg&& __x); + + template + iterator + _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&); + + template + iterator + _M_insert_unique_(const_iterator __pos, _Arg&& __x) + { + _Alloc_node __an(*this); + return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an); + } + + template + iterator + _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&); + + template + iterator + _M_insert_equal_(const_iterator __pos, _Arg&& __x) + { + _Alloc_node __an(*this); + return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an); + } + + template + pair + _M_emplace_unique(_Args&&... __args); + + template + iterator + _M_emplace_equal(_Args&&... __args); + + template + iterator + _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args); + + template + iterator + _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args); + + template + using __same_value_type + =3D is_same::value_type>; + + template + __enable_if_t<__same_value_type<_InputIterator>::value> + _M_insert_range_unique(_InputIterator __first, _InputIterator __last) + { + _Alloc_node __an(*this); + for (; __first !=3D __last; ++__first) + _M_insert_unique_(end(), *__first, __an); + } + + template + __enable_if_t::value> + _M_insert_range_unique(_InputIterator __first, _InputIterator __last) + { + for (; __first !=3D __last; ++__first) + _M_emplace_unique(*__first); + } + + template + __enable_if_t<__same_value_type<_InputIterator>::value> + _M_insert_range_equal(_InputIterator __first, _InputIterator __last) + { + _Alloc_node __an(*this); + for (; __first !=3D __last; ++__first) + _M_insert_equal_(end(), *__first, __an); + } + + template + __enable_if_t::value> + _M_insert_range_equal(_InputIterator __first, _InputIterator __last) + { + for (; __first !=3D __last; ++__first) + _M_emplace_equal(*__first); + } +# 1180 "/usr/include/c++/13/bits/stl_tree.h" 3 + private: + void + _M_erase_aux(const_iterator __position); + + void + _M_erase_aux(const_iterator __first, const_iterator __last); + + public: + + + + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __position) + { + do { if (std::__is_constant_evaluated() && !bool(__position !=3D end())) = __builtin_unreachable(); } while (false); + const_iterator __result =3D __position; + ++__result; + _M_erase_aux(__position); + return __result._M_const_cast(); + } + + + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(iterator __position) + { + do { if (std::__is_constant_evaluated() && !bool(__position !=3D end())) = __builtin_unreachable(); } while (false); + iterator __result =3D __position; + ++__result; + _M_erase_aux(__position); + return __result; + } +# 1229 "/usr/include/c++/13/bits/stl_tree.h" 3 + size_type + erase(const key_type& __x); + + + + + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __first, const_iterator __last) + { + _M_erase_aux(__first, __last); + return __last._M_const_cast(); + } +# 1252 "/usr/include/c++/13/bits/stl_tree.h" 3 + void + clear() noexcept + { + _M_erase(_M_begin()); + _M_impl._M_reset(); + } + + + iterator + find(const key_type& __k); + + const_iterator + find(const key_type& __k) const; + + size_type + count(const key_type& __k) const; + + iterator + lower_bound(const key_type& __k) + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + const_iterator + lower_bound(const key_type& __k) const + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + iterator + upper_bound(const key_type& __k) + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + const_iterator + upper_bound(const key_type& __k) const + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + pair + equal_range(const key_type& __k); + + pair + equal_range(const key_type& __k) const; + + + template> + iterator + _M_find_tr(const _Kt& __k) + { + const _Rb_tree* __const_this =3D this; + return __const_this->_M_find_tr(__k)._M_const_cast(); + } + + template> + const_iterator + _M_find_tr(const _Kt& __k) const + { + auto __j =3D _M_lower_bound_tr(__k); + if (__j !=3D end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node))) + __j =3D end(); + return __j; + } + + template> + size_type + _M_count_tr(const _Kt& __k) const + { + auto __p =3D _M_equal_range_tr(__k); + return std::distance(__p.first, __p.second); + } + + template> + iterator + _M_lower_bound_tr(const _Kt& __k) + { + const _Rb_tree* __const_this =3D this; + return __const_this->_M_lower_bound_tr(__k)._M_const_cast(); + } + + template> + const_iterator + _M_lower_bound_tr(const _Kt& __k) const + { + auto __x =3D _M_begin(); + auto __y =3D _M_end(); + while (__x !=3D 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + { + __y =3D __x; + __x =3D _S_left(__x); + } + else + __x =3D _S_right(__x); + return const_iterator(__y); + } + + template> + iterator + _M_upper_bound_tr(const _Kt& __k) + { + const _Rb_tree* __const_this =3D this; + return __const_this->_M_upper_bound_tr(__k)._M_const_cast(); + } + + template> + const_iterator + _M_upper_bound_tr(const _Kt& __k) const + { + auto __x =3D _M_begin(); + auto __y =3D _M_end(); + while (__x !=3D 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + { + __y =3D __x; + __x =3D _S_left(__x); + } + else + __x =3D _S_right(__x); + return const_iterator(__y); + } + + template> + pair + _M_equal_range_tr(const _Kt& __k) + { + const _Rb_tree* __const_this =3D this; + auto __ret =3D __const_this->_M_equal_range_tr(__k); + return { __ret.first._M_const_cast(), __ret.second._M_const_cast() }; + } + + template> + pair + _M_equal_range_tr(const _Kt& __k) const + { + auto __low =3D _M_lower_bound_tr(__k); + auto __high =3D __low; + auto& __cmp =3D _M_impl._M_key_compare; + while (__high !=3D end() && !__cmp(__k, _S_key(__high._M_node))) + ++__high; + return { __low, __high }; + } + + + + bool + __rb_verify() const; + + + _Rb_tree& + operator=3D(_Rb_tree&&) + noexcept(_Alloc_traits::_S_nothrow_move() + && is_nothrow_move_assignable<_Compare>::value); + + template + void + _M_assign_unique(_Iterator, _Iterator); + + template + void + _M_assign_equal(_Iterator, _Iterator); + + private: + + void + _M_move_data(_Rb_tree& __x, true_type) + { _M_impl._M_move_data(__x._M_impl); } + + + + void + _M_move_data(_Rb_tree&, false_type); + + + void + _M_move_assign(_Rb_tree&, true_type); + + + + void + _M_move_assign(_Rb_tree&, false_type); + + + + public: + + insert_return_type + _M_reinsert_node_unique(node_type&& __nh) + { + insert_return_type __ret; + if (__nh.empty()) + __ret.position =3D end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocato= r() =3D=3D *__nh._M_alloc)) __builtin_unreachable(); } while (false); + + auto __res =3D _M_get_insert_unique_pos(__nh._M_key()); + if (__res.second) + { + __ret.position + =3D _M_insert_node(__res.first, __res.second, __nh._M_ptr); + __nh._M_ptr =3D nullptr; + __ret.inserted =3D true; + } + else + { + __ret.node =3D std::move(__nh); + __ret.position =3D iterator(__res.first); + __ret.inserted =3D false; + } + } + return __ret; + } + + + iterator + _M_reinsert_node_equal(node_type&& __nh) + { + iterator __ret; + if (__nh.empty()) + __ret =3D end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocato= r() =3D=3D *__nh._M_alloc)) __builtin_unreachable(); } while (false); + auto __res =3D _M_get_insert_equal_pos(__nh._M_key()); + if (__res.second) + __ret =3D _M_insert_node(__res.first, __res.second, __nh._M_ptr); + else + __ret =3D _M_insert_equal_lower_node(__nh._M_ptr); + __nh._M_ptr =3D nullptr; + } + return __ret; + } + + + iterator + _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh) + { + iterator __ret; + if (__nh.empty()) + __ret =3D end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocato= r() =3D=3D *__nh._M_alloc)) __builtin_unreachable(); } while (false); + auto __res =3D _M_get_insert_hint_unique_pos(__hint, __nh._M_key()); + if (__res.second) + { + __ret =3D _M_insert_node(__res.first, __res.second, __nh._M_ptr); + __nh._M_ptr =3D nullptr; + } + else + __ret =3D iterator(__res.first); + } + return __ret; + } + + + iterator + _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh) + { + iterator __ret; + if (__nh.empty()) + __ret =3D end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocato= r() =3D=3D *__nh._M_alloc)) __builtin_unreachable(); } while (false); + auto __res =3D _M_get_insert_hint_equal_pos(__hint, __nh._M_key()); + if (__res.second) + __ret =3D _M_insert_node(__res.first, __res.second, __nh._M_ptr); + else + __ret =3D _M_insert_equal_lower_node(__nh._M_ptr); + __nh._M_ptr =3D nullptr; + } + return __ret; + } + + + node_type + extract(const_iterator __pos) + { + auto __ptr =3D _Rb_tree_rebalance_for_erase( + __pos._M_const_cast()._M_node, _M_impl._M_header); + --_M_impl._M_node_count; + return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() }; + } + + + node_type + extract(const key_type& __k) + { + node_type __nh; + auto __pos =3D find(__k); + if (__pos !=3D end()) + __nh =3D extract(const_iterator(__pos)); + return __nh; + } + + template + using _Compatible_tree + =3D _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>; + + template + friend class _Rb_tree_merge_helper; + + + template + void + _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept + { + using _Merge_helper =3D _Rb_tree_merge_helper<_Rb_tree, _Compare2>; + for (auto __i =3D __src.begin(), __end =3D __src.end(); __i !=3D __end;) + { + auto __pos =3D __i++; + auto __res =3D _M_get_insert_unique_pos(_KeyOfValue()(*__pos)); + if (__res.second) + { + auto& __src_impl =3D _Merge_helper::_S_get_impl(__src); + auto __ptr =3D _Rb_tree_rebalance_for_erase( + __pos._M_node, __src_impl._M_header); + --__src_impl._M_node_count; + _M_insert_node(__res.first, __res.second, + static_cast<_Link_type>(__ptr)); + } + } + } + + + template + void + _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept + { + using _Merge_helper =3D _Rb_tree_merge_helper<_Rb_tree, _Compare2>; + for (auto __i =3D __src.begin(), __end =3D __src.end(); __i !=3D __end;) + { + auto __pos =3D __i++; + auto __res =3D _M_get_insert_equal_pos(_KeyOfValue()(*__pos)); + if (__res.second) + { + auto& __src_impl =3D _Merge_helper::_S_get_impl(__src); + auto __ptr =3D _Rb_tree_rebalance_for_erase( + __pos._M_node, __src_impl._M_header); + --__src_impl._M_node_count; + _M_insert_node(__res.first, __res.second, + static_cast<_Link_type>(__ptr)); + } + } + } + + + friend bool + operator=3D=3D(const _Rb_tree& __x, const _Rb_tree& __y) + { + return __x.size() =3D=3D __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin()); + } +# 1621 "/usr/include/c++/13/bits/stl_tree.h" 3 + friend bool + operator<(const _Rb_tree& __x, const _Rb_tree& __y) + { + return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); + } + + + private: + + + struct _Auto_node + { + template + _Auto_node(_Rb_tree& __t, _Args&&... __args) + : _M_t(__t), + _M_node(__t._M_create_node(std::forward<_Args>(__args)...)) + { } + + ~_Auto_node() + { + if (_M_node) + _M_t._M_drop_node(_M_node); + } + + _Auto_node(_Auto_node&& __n) + : _M_t(__n._M_t), _M_node(__n._M_node) + { __n._M_node =3D nullptr; } + + const _Key& + _M_key() const + { return _S_key(_M_node); } + + iterator + _M_insert(pair<_Base_ptr, _Base_ptr> __p) + { + auto __it =3D _M_t._M_insert_node(__p.first, __p.second, _M_node); + _M_node =3D nullptr; + return __it; + } + + iterator + _M_insert_equal_lower() + { + auto __it =3D _M_t._M_insert_equal_lower_node(_M_node); + _M_node =3D nullptr; + return __it; + } + + _Rb_tree& _M_t; + _Link_type _M_node; + }; + + }; + + template + inline void + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { __x.swap(__y); } + + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_data(_Rb_tree& __x, false_type) + { + if (_M_get_Node_allocator() =3D=3D __x._M_get_Node_allocator()) + _M_move_data(__x, true_type()); + else + { + constexpr bool __move =3D !__move_if_noexcept_cond::value; + _Alloc_node __an(*this); + _M_root() =3D _M_copy<__move>(__x, __an); + if constexpr (__move) + __x.clear(); + } + } + + template + inline void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_assign(_Rb_tree& __x, true_type) + { + clear(); + if (__x._M_root() !=3D nullptr) + _M_move_data(__x, true_type()); + std::__alloc_on_move(_M_get_Node_allocator(), + __x._M_get_Node_allocator()); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_assign(_Rb_tree& __x, false_type) + { + if (_M_get_Node_allocator() =3D=3D __x._M_get_Node_allocator()) + return _M_move_assign(__x, true_type{}); + + + + _Reuse_or_alloc_node __roan(*this); + _M_impl._M_reset(); + if (__x._M_root() !=3D nullptr) + { + _M_root() =3D _M_copy<__as_rvalue>(__x, __roan); + __x.clear(); + } + } + + template + inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + operator=3D(_Rb_tree&& __x) + noexcept(_Alloc_traits::_S_nothrow_move() + && is_nothrow_move_assignable<_Compare>::value) + { + _M_impl._M_key_compare =3D std::move(__x._M_impl._M_key_compare); + _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()= >()); + return *this; + } + + template + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_assign_unique(_Iterator __first, _Iterator __last) + { + _Reuse_or_alloc_node __roan(*this); + _M_impl._M_reset(); + for (; __first !=3D __last; ++__first) + _M_insert_unique_(end(), *__first, __roan); + } + + template + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_assign_equal(_Iterator __first, _Iterator __last) + { + _Reuse_or_alloc_node __roan(*this); + _M_impl._M_reset(); + for (; __first !=3D __last; ++__first) + _M_insert_equal_(end(), *__first, __roan); + } + + + template + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + operator=3D(const _Rb_tree& __x) + { + if (this !=3D std::__addressof(__x)) + { + + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc =3D this->_M_get_Node_allocator(); + auto& __that_alloc =3D __x._M_get_Node_allocator(); + if (!_Alloc_traits::_S_always_equal() + && __this_alloc !=3D __that_alloc) + { + + + clear(); + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + } + + + _Reuse_or_alloc_node __roan(*this); + _M_impl._M_reset(); + _M_impl._M_key_compare =3D __x._M_impl._M_key_compare; + if (__x._M_root() !=3D 0) + _M_root() =3D _M_copy<__as_lvalue>(__x, __roan); + } + + return *this; + } + + template + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterat= or + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_(_Base_ptr __x, _Base_ptr __p, + + _Arg&& __v, + + + + _NodeGen& __node_gen) + { + bool __insert_left =3D (__x !=3D 0 || __p =3D=3D _M_end() + || _M_impl._M_key_compare(_KeyOfValue()(__v), + _S_key(__p))); + + _Link_type __z =3D __node_gen(std::forward<_Arg>(__v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + _M_insert_lower(_Base_ptr __p, _Arg&& __v) + + + + { + bool __insert_left =3D (__p =3D=3D _M_end() + || !_M_impl._M_key_compare(_S_key(__p), + _KeyOfValue()(__v))); + + _Link_type __z =3D _M_create_node(std::forward<_Arg>(__v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + _M_insert_equal_lower(_Arg&& __v) + + + + { + _Link_type __x =3D _M_begin(); + _Base_ptr __y =3D _M_end(); + while (__x !=3D 0) + { + __y =3D __x; + __x =3D !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? + _S_left(__x) : _S_right(__x); + } + return _M_insert_lower(__y, std::forward<_Arg>(__v)); + } + + template + template + typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type + _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: + _M_copy(_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen) + { + + _Link_type __top =3D _M_clone_node<_MoveValues>(__x, __node_gen); + __top->_M_parent =3D __p; + + if (true) + { + if (__x->_M_right) + __top->_M_right =3D + _M_copy<_MoveValues>(_S_right(__x), __top, __node_gen); + __p =3D __top; + __x =3D _S_left(__x); + + while (__x !=3D 0) + { + _Link_type __y =3D _M_clone_node<_MoveValues>(__x, __node_gen); + __p->_M_left =3D __y; + __y->_M_parent =3D __p; + if (__x->_M_right) + __y->_M_right =3D _M_copy<_MoveValues>(_S_right(__x), + __y, __node_gen); + __p =3D __y; + __x =3D _S_left(__x); + } + } + if (false) + { + _M_erase(__top); + ; + } + return __top; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase(_Link_type __x) + { + + while (__x !=3D 0) + { + _M_erase(_S_right(__x)); + _Link_type __y =3D _S_left(__x); + _M_drop_node(__x); + __x =3D __y; + } + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Link_type __x, _Base_ptr __y, + const _Key& __k) + { + while (__x !=3D 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y =3D __x, __x =3D _S_left(__x); + else + __x =3D _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y, + const _Key& __k) const + { + while (__x !=3D 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y =3D __x, __x =3D _S_left(__x); + else + __x =3D _S_right(__x); + return const_iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Link_type __x, _Base_ptr __y, + const _Key& __k) + { + while (__x !=3D 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y =3D __x, __x =3D _S_left(__x); + else + __x =3D _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y, + const _Key& __k) const + { + while (__x !=3D 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y =3D __x, __x =3D _S_left(__x); + else + __x =3D _S_right(__x); + return const_iterator(__y); + } + + template + pair::iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) + { + _Link_type __x =3D _M_begin(); + _Base_ptr __y =3D _M_end(); + while (__x !=3D 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x =3D _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y =3D __x, __x =3D _S_left(__x); + else + { + _Link_type __xu(__x); + _Base_ptr __yu(__y); + __y =3D __x, __x =3D _S_left(__x); + __xu =3D _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(iterator(__y), + iterator(__y)); + } + + template + pair::const_iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) const + { + _Const_Link_type __x =3D _M_begin(); + _Const_Base_ptr __y =3D _M_end(); + while (__x !=3D 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x =3D _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y =3D __x, __x =3D _S_left(__x); + else + { + _Const_Link_type __xu(__x); + _Const_Base_ptr __yu(__y); + __y =3D __x, __x =3D _S_left(__x); + __xu =3D _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(const_iterator(__y), + const_iterator(__y)); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + swap(_Rb_tree& __t) + noexcept(__is_nothrow_swappable<_Compare>::value) + { + if (_M_root() =3D=3D 0) + { + if (__t._M_root() !=3D 0) + _M_impl._M_move_data(__t._M_impl); + } + else if (__t._M_root() =3D=3D 0) + __t._M_impl._M_move_data(_M_impl); + else + { + std::swap(_M_root(),__t._M_root()); + std::swap(_M_leftmost(),__t._M_leftmost()); + std::swap(_M_rightmost(),__t._M_rightmost()); + + _M_root()->_M_parent =3D _M_end(); + __t._M_root()->_M_parent =3D __t._M_end(); + std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count); + } + + std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare); + + _Alloc_traits::_S_on_swap(_M_get_Node_allocator(), + __t._M_get_Node_allocator()); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_unique_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x =3D _M_begin(); + _Base_ptr __y =3D _M_end(); + bool __comp =3D true; + while (__x !=3D 0) + { + __y =3D __x; + __comp =3D _M_impl._M_key_compare(__k, _S_key(__x)); + __x =3D __comp ? _S_left(__x) : _S_right(__x); + } + iterator __j =3D iterator(__y); + if (__comp) + { + if (__j =3D=3D begin()) + return _Res(__x, __y); + else + --__j; + } + if (_M_impl._M_key_compare(_S_key(__j._M_node), __k)) + return _Res(__x, __y); + return _Res(__j._M_node, 0); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_equal_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x =3D _M_begin(); + _Base_ptr __y =3D _M_end(); + while (__x !=3D 0) + { + __y =3D __x; + __x =3D _M_impl._M_key_compare(__k, _S_key(__x)) ? + _S_left(__x) : _S_right(__x); + } + return _Res(__x, __y); + } + + template + + template + + pair::iterator, bool> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + _M_insert_unique(_Arg&& __v) + + + + { + typedef pair _Res; + pair<_Base_ptr, _Base_ptr> __res + =3D _M_get_insert_unique_pos(_KeyOfValue()(__v)); + + if (__res.second) + { + _Alloc_node __an(*this); + return _Res(_M_insert_(__res.first, __res.second, + std::forward<_Arg>(__v), __an), + true); + } + + return _Res(iterator(__res.first), false); + } + + template + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + _M_insert_equal(_Arg&& __v) + + + + { + pair<_Base_ptr, _Base_ptr> __res + =3D _M_get_insert_equal_pos(_KeyOfValue()(__v)); + _Alloc_node __an(*this); + return _M_insert_(__res.first, __res.second, + std::forward<_Arg>(__v), __an); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_unique_pos(const_iterator __position, + const key_type& __k) + { + iterator __pos =3D __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + + if (__pos._M_node =3D=3D _M_end()) + { + if (size() > 0 + && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k)) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node))) + { + + iterator __before =3D __pos; + if (__pos._M_node =3D=3D _M_leftmost()) + return _Res(_M_leftmost(), _M_leftmost()); + else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k)) + { + if (_S_right(__before._M_node) =3D=3D 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + + iterator __after =3D __pos; + if (__pos._M_node =3D=3D _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node))) + { + if (_S_right(__pos._M_node) =3D=3D 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else + + return _Res(__pos._M_node, 0); + } + + template + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterat= or + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_unique_(const_iterator __position, + + _Arg&& __v, + + + + _NodeGen& __node_gen) + { + pair<_Base_ptr, _Base_ptr> __res + =3D _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + std::forward<_Arg>(__v), + __node_gen); + return iterator(__res.first); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_equal_pos(const_iterator __position, const key_type= & __k) + { + iterator __pos =3D __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + + if (__pos._M_node =3D=3D _M_end()) + { + if (size() > 0 + && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost()))) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_equal_pos(__k); + } + else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + + iterator __before =3D __pos; + if (__pos._M_node =3D=3D _M_leftmost()) + return _Res(_M_leftmost(), _M_leftmost()); + else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node))) + { + if (_S_right(__before._M_node) =3D=3D 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_equal_pos(__k); + } + else + { + + iterator __after =3D __pos; + if (__pos._M_node =3D=3D _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k)) + { + if (_S_right(__pos._M_node) =3D=3D 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _Res(0, 0); + } + } + + template + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterat= or + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_equal_(const_iterator __position, + + _Arg&& __v, + + + + _NodeGen& __node_gen) + { + pair<_Base_ptr, _Base_ptr> __res + =3D _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + std::forward<_Arg>(__v), + __node_gen); + + return _M_insert_equal_lower(std::forward<_Arg>(__v)); + } + + + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z) + -> iterator + { + bool __insert_left =3D (__x !=3D 0 || __p =3D=3D _M_end() + || _M_impl._M_key_compare(_S_key(__z), + _S_key(__p))); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_lower_node(_Base_ptr __p, _Link_type __z) + -> iterator + { + bool __insert_left =3D (__p =3D=3D _M_end() + || !_M_impl._M_key_compare(_S_key(__p), + _S_key(__z))); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_equal_lower_node(_Link_type __z) + -> iterator + { + _Link_type __x =3D _M_begin(); + _Base_ptr __y =3D _M_end(); + while (__x !=3D 0) + { + __y =3D __x; + __x =3D !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ? + _S_left(__x) : _S_right(__x); + } + return _M_insert_lower_node(__y, __z); + } + + template + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_unique(_Args&&... __args) + -> pair + { + _Auto_node __z(*this, std::forward<_Args>(__args)...); + auto __res =3D _M_get_insert_unique_pos(__z._M_key()); + if (__res.second) + return {__z._M_insert(__res), true}; + return {iterator(__res.first), false}; + } + + template + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_equal(_Args&&... __args) + -> iterator + { + _Auto_node __z(*this, std::forward<_Args>(__args)...); + auto __res =3D _M_get_insert_equal_pos(__z._M_key()); + return __z._M_insert(__res); + } + + template + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args) + -> iterator + { + _Auto_node __z(*this, std::forward<_Args>(__args)...); + auto __res =3D _M_get_insert_hint_unique_pos(__pos, __z._M_key()); + if (__res.second) + return __z._M_insert(__res); + return iterator(__res.first); + } + + template + template + auto + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args) + -> iterator + { + _Auto_node __z(*this, std::forward<_Args>(__args)...); + auto __res =3D _M_get_insert_hint_equal_pos(__pos, __z._M_key()); + if (__res.second) + return __z._M_insert(__res); + return __z._M_insert_equal_lower(); + } + + + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __position) + { + _Link_type __y =3D + static_cast<_Link_type>(_Rb_tree_rebalance_for_erase + (const_cast<_Base_ptr>(__position._M_node), + this->_M_impl._M_header)); + _M_drop_node(__y); + --_M_impl._M_node_count; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __first, const_iterator __last) + { + if (__first =3D=3D begin() && __last =3D=3D end()) + clear(); + else + while (__first !=3D __last) + _M_erase_aux(__first++); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const _Key& __x) + { + pair __p =3D equal_range(__x); + const size_type __old_size =3D size(); + _M_erase_aux(__p.first, __p.second); + return __old_size - size(); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) + { + iterator __j =3D _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j =3D=3D end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) const + { + const_iterator __j =3D _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j =3D=3D end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + count(const _Key& __k) const + { + pair __p =3D equal_range(__k); + const size_type __n =3D std::distance(__p.first, __p.second); + return __n; + } + + __attribute__ ((__pure__)) unsigned int + _Rb_tree_black_count(const _Rb_tree_node_base* __node, + const _Rb_tree_node_base* __root) throw (); + + template + bool + _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const + { + if (_M_impl._M_node_count =3D=3D 0 || begin() =3D=3D end()) + return _M_impl._M_node_count =3D=3D 0 && begin() =3D=3D end() + && this->_M_impl._M_header._M_left =3D=3D _M_end() + && this->_M_impl._M_header._M_right =3D=3D _M_end(); + + unsigned int __len =3D _Rb_tree_black_count(_M_leftmost(), _M_root()= ); + for (const_iterator __it =3D begin(); __it !=3D end(); ++__it) + { + _Const_Link_type __x =3D static_cast<_Const_Link_type>(__it._M_node); + _Const_Link_type __L =3D _S_left(__x); + _Const_Link_type __R =3D _S_right(__x); + + if (__x->_M_color =3D=3D _S_red) + if ((__L && __L->_M_color =3D=3D _S_red) + || (__R && __R->_M_color =3D=3D _S_red)) + return false; + + if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L))) + return false; + if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x))) + return false; + + if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) !=3D __len) + return false; + } + + if (_M_leftmost() !=3D _Rb_tree_node_base::_S_minimum(_M_root())) + return false; + if (_M_rightmost() !=3D _Rb_tree_node_base::_S_maximum(_M_root())) + return false; + return true; + } + + + + template + struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>, + _Cmp2> + { + private: + friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>; + + static auto& + _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree) + { return __tree._M_impl; } + }; + + + +} +# 63 "/usr/include/c++/13/map" 2 3 +# 1 "/usr/include/c++/13/bits/stl_map.h" 1 3 +# 66 "/usr/include/c++/13/bits/stl_map.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class multimap; +# 98 "/usr/include/c++/13/bits/stl_map.h" 3 + template , + typename _Alloc =3D std::allocator > > + class map + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: +# 128 "/usr/include/c++/13/bits/stl_map.h" 3 + public: +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + class value_compare + : public std::binary_function + { + friend class map<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; +#pragma GCC diagnostic pop + + private: + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + + + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + + template> + static constexpr bool __usable_key + =3D __or_v, + __and_, is_scalar<_Key>>>; + + + public: + + + typedef typename _Alloc_traits::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 typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_ite= rator; + + + using node_type =3D typename _Rep_type::node_type; + using insert_return_type =3D typename _Rep_type::insert_return_type; +# 195 "/usr/include/c++/13/bits/stl_map.h" 3 + map() =3D default; + + + + + + + + explicit + map(const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } +# 217 "/usr/include/c++/13/bits/stl_map.h" 3 + map(const map&) =3D default; + + + + + + + + map(map&&) =3D default; +# 238 "/usr/include/c++/13/bits/stl_map.h" 3 + map(initializer_list __l, + const _Compare& __comp =3D _Compare(), + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } + + + explicit + map(const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) { } + + + map(const map& __m, const __type_identity_t& __a) + : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } + + + map(map&& __m, const __type_identity_t& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } + + + map(initializer_list __l, const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) + { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } + + + template + map(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) + { _M_t._M_insert_range_unique(__first, __last); } +# 282 "/usr/include/c++/13/bits/stl_map.h" 3 + template + map(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_range_unique(__first, __last); } +# 299 "/usr/include/c++/13/bits/stl_map.h" 3 + template + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_range_unique(__first, __last); } + + + + + + + + ~map() =3D default; +# 328 "/usr/include/c++/13/bits/stl_map.h" 3 + map& + operator=3D(const map&) =3D default; + + + map& + operator=3D(map&&) =3D default; +# 346 "/usr/include/c++/13/bits/stl_map.h" 3 + map& + operator=3D(initializer_list __l) + { + _M_t._M_assign_unique(__l.begin(), __l.end()); + return *this; + } + + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_t.get_allocator()); } + + + + + + + + iterator + begin() noexcept + { return _M_t.begin(); } + + + + + + + const_iterator + begin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + end() noexcept + { return _M_t.end(); } + + + + + + + const_iterator + end() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() noexcept + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + rbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() noexcept + { return _M_t.rend(); } + + + + + + + const_reverse_iterator + rend() const noexcept + { return _M_t.rend(); } + + + + + + + + const_iterator + cbegin() const noexcept + { return _M_t.begin(); } + + + + + + + const_iterator + cend() const noexcept + { return _M_t.end(); } + + + + + + + const_reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + crend() const noexcept + { return _M_t.rend(); } + + + + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_t.empty(); } + + + size_type + size() const noexcept + { return _M_t.size(); } + + + size_type + max_size() const noexcept + { return _M_t.max_size(); } +# 501 "/usr/include/c++/13/bits/stl_map.h" 3 + mapped_type& + operator[](const key_type& __k) + { + + + + iterator __i =3D lower_bound(__k); + + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + + __i =3D _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, + std::tuple(__k), + std::tuple<>()); + + + + return (*__i).second; + } + + + mapped_type& + operator[](key_type&& __k) + { + + + + iterator __i =3D lower_bound(__k); + + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + __i =3D _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::tuple<>()); + return (*__i).second; + } +# 546 "/usr/include/c++/13/bits/stl_map.h" 3 + mapped_type& + at(const key_type& __k) + { + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(("map::at")); + return (*__i).second; + } + + const mapped_type& + at(const key_type& __k) const + { + const_iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(("map::at")); + return (*__i).second; + } +# 584 "/usr/include/c++/13/bits/stl_map.h" 3 + template + std::pair + emplace(_Args&&... __args) + { + + if constexpr (sizeof...(_Args) =3D=3D 2) + if constexpr (is_same_v>) + { + auto&& [__a, __v] =3D pair<_Args&...>(__args...); + if constexpr (__usable_key) + { + const key_type& __k =3D __a; + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::forward<_Args>(__args)...); + return {__i, true}; + } + return {__i, false}; + } + } + + return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); + } +# 634 "/usr/include/c++/13/bits/stl_map.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_unique(__pos, + std::forward<_Args>(__args)...); + } + + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos !=3D end())) __bui= ltin_unreachable(); } while (false); + return _M_t.extract(__pos); + } + + + node_type + extract(const key_type& __x) + { return _M_t.extract(__x); } + + + insert_return_type + insert(node_type&& __nh) + { return _M_t._M_reinsert_node_unique(std::move(__nh)); } + + + iterator + insert(const_iterator __hint, node_type&& __nh) + { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh));= } + + template + friend struct std::_Rb_tree_merge_helper; + + template + void + merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source) + { merge(__source); } +# 719 "/usr/include/c++/13/bits/stl_map.h" 3 + template + pair + try_emplace(const key_type& __k, _Args&&... __args) + { + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple( + std::forward<_Args>(__args)...)); + return {__i, true}; + } + return {__i, false}; + } + + + template + pair + try_emplace(key_type&& __k, _Args&&... __args) + { + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple( + std::forward<_Args>(__args)...)); + return {__i, true}; + } + return {__i, false}; + } +# 779 "/usr/include/c++/13/bits/stl_map.h" 3 + template + iterator + try_emplace(const_iterator __hint, const key_type& __k, + _Args&&... __args) + { + iterator __i; + auto __true_hint =3D _M_t._M_get_insert_hint_unique_pos(__hint, __k); + if (__true_hint.second) + __i =3D emplace_hint(iterator(__true_hint.second), + std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple( + std::forward<_Args>(__args)...)); + else + __i =3D iterator(__true_hint.first); + return __i; + } + + + template + iterator + try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) + { + iterator __i; + auto __true_hint =3D _M_t._M_get_insert_hint_unique_pos(__hint, __k); + if (__true_hint.second) + __i =3D emplace_hint(iterator(__true_hint.second), + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple( + std::forward<_Args>(__args)...)); + else + __i =3D iterator(__true_hint.first); + return __i; + } +# 832 "/usr/include/c++/13/bits/stl_map.h" 3 + std::pair + insert(const value_type& __x) + { return _M_t._M_insert_unique(__x); } + + + + + std::pair + insert(value_type&& __x) + { return _M_t._M_insert_unique(std::move(__x)); } + + template + __enable_if_t::value, + pair> + insert(_Pair&& __x) + { + + using _P2 =3D remove_reference_t<_Pair>; + if constexpr (__is_pair>) + if constexpr (is_same_v>) + if constexpr (__usable_key) + { + const key_type& __k =3D __x.first; + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::forward<_Pair>(__x)); + return {__i, true}; + } + return {__i, false}; + } + + return _M_t._M_emplace_unique(std::forward<_Pair>(__x)); + } +# 877 "/usr/include/c++/13/bits/stl_map.h" 3 + void + insert(std::initializer_list __list) + { insert(__list.begin(), __list.end()); } +# 906 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + + insert(const_iterator __position, const value_type& __x) + + + + { return _M_t._M_insert_unique_(__position, __x); } + + + + + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_unique_(__position, std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(const_iterator __position, _Pair&& __x) + { + return _M_t._M_emplace_hint_unique(__position, + std::forward<_Pair>(__x)); + } +# 939 "/usr/include/c++/13/bits/stl_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_range_unique(__first, __last); } +# 964 "/usr/include/c++/13/bits/stl_map.h" 3 + template + pair + insert_or_assign(const key_type& __k, _Obj&& __obj) + { + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple( + std::forward<_Obj>(__obj))); + return {__i, true}; + } + (*__i).second =3D std::forward<_Obj>(__obj); + return {__i, false}; + } + + + template + pair + insert_or_assign(key_type&& __k, _Obj&& __obj) + { + iterator __i =3D lower_bound(__k); + if (__i =3D=3D end() || key_comp()(__k, (*__i).first)) + { + __i =3D emplace_hint(__i, std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple( + std::forward<_Obj>(__obj))); + return {__i, true}; + } + (*__i).second =3D std::forward<_Obj>(__obj); + return {__i, false}; + } +# 1019 "/usr/include/c++/13/bits/stl_map.h" 3 + template + iterator + insert_or_assign(const_iterator __hint, + const key_type& __k, _Obj&& __obj) + { + iterator __i; + auto __true_hint =3D _M_t._M_get_insert_hint_unique_pos(__hint, __k); + if (__true_hint.second) + { + return emplace_hint(iterator(__true_hint.second), + std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple( + std::forward<_Obj>(__obj))); + } + __i =3D iterator(__true_hint.first); + (*__i).second =3D std::forward<_Obj>(__obj); + return __i; + } + + + template + iterator + insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) + { + iterator __i; + auto __true_hint =3D _M_t._M_get_insert_hint_unique_pos(__hint, __k); + if (__true_hint.second) + { + return emplace_hint(iterator(__true_hint.second), + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple( + std::forward<_Obj>(__obj))); + } + __i =3D iterator(__true_hint.first); + (*__i).second =3D std::forward<_Obj>(__obj); + return __i; + } +# 1078 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } + + + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +# 1115 "/usr/include/c++/13/bits/stl_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 1135 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +# 1169 "/usr/include/c++/13/bits/stl_map.h" 3 + void + swap(map& __x) + noexcept(__is_nothrow_swappable<_Compare>::value) + { _M_t.swap(__x._M_t); } + + + + + + + + void + clear() noexcept + { _M_t.clear(); } + + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + + + + + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } +# 1216 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x)) + { return _M_t._M_find_tr(__x); } +# 1241 "/usr/include/c++/13/bits/stl_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x)) + { return _M_t._M_find_tr(__x); } +# 1262 "/usr/include/c++/13/bits/stl_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.find(__x) =3D=3D _M_t.end() ? 0 : 1; } + + + template + auto + count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) + { return _M_t._M_count_tr(__x); } +# 1305 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) + { return iterator(_M_t._M_lower_bound_tr(__x)); } +# 1330 "/usr/include/c++/13/bits/stl_map.h" 3 + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) const + -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) + { return const_iterator(_M_t._M_lower_bound_tr(__x)); } +# 1350 "/usr/include/c++/13/bits/stl_map.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return iterator(_M_t._M_upper_bound_tr(__x)); } +# 1370 "/usr/include/c++/13/bits/stl_map.h" 3 + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) const + -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x))) + { return const_iterator(_M_t._M_upper_bound_tr(__x)); } +# 1399 "/usr/include/c++/13/bits/stl_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } +# 1428 "/usr/include/c++/13/bits/stl_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) const + -> decltype(pair( + _M_t._M_equal_range_tr(__x))) + { + return pair( + _M_t._M_equal_range_tr(__x)); + } + + + + template + friend bool + operator=3D=3D(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + + + + + + + + template + friend bool + operator<(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + + }; + + + + + template>, + typename _Allocator =3D allocator<__iter_to_alloc_t<_InputIterator>>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + map(_InputIterator, _InputIterator, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, + _Compare, _Allocator>; + + template, + typename _Allocator =3D allocator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + map(initializer_list>, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> map<_Key, _Tp, _Compare, _Allocator>; + + template , + typename =3D _RequireAllocator<_Allocator>> + map(_InputIterator, _InputIterator, _Allocator) + -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, + less<__iter_key_t<_InputIterator>>, _Allocator>; + + template> + map(initializer_list>, _Allocator) + -> map<_Key, _Tp, less<_Key>, _Allocator>; +# 1509 "/usr/include/c++/13/bits/stl_map.h" 3 + template + inline bool + operator=3D=3D(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t =3D=3D __y._M_t; } +# 1547 "/usr/include/c++/13/bits/stl_map.h" 3 + template + inline bool + operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=3D(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=3D(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=3D(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + + template + inline void + swap(map<_Key, _Tp, _Compare, _Alloc>& __x, + map<_Key, _Tp, _Compare, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + + template + struct + _Rb_tree_merge_helper, + _Cmp2> + { + private: + friend class std::map<_Key, _Val, _Cmp1, _Alloc>; + + static auto& + _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map) + { return __map._M_t; } + + static auto& + _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map) + { return __map._M_t; } + }; + + + +} +# 64 "/usr/include/c++/13/map" 2 3 +# 1 "/usr/include/c++/13/bits/stl_multimap.h" 1 3 +# 64 "/usr/include/c++/13/bits/stl_multimap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class map; +# 96 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template , + typename _Alloc =3D std::allocator > > + class multimap + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: +# 127 "/usr/include/c++/13/bits/stl_multimap.h" 3 + public: +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + class value_compare + : public std::binary_function + { + friend class multimap<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; +#pragma GCC diagnostic pop + + private: + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + public: + + + typedef typename _Alloc_traits::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 typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_ite= rator; + + + using node_type =3D typename _Rep_type::node_type; +# 185 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap() =3D default; + + + + + + + + explicit + multimap(const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } +# 207 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap(const multimap&) =3D default; +# 216 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap(multimap&&) =3D default; +# 228 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap(initializer_list __l, + const _Compare& __comp =3D _Compare(), + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } + + + explicit + multimap(const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) { } + + + multimap(const multimap& __m, + const __type_identity_t& __a) + : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } + + + multimap(multimap&& __m, const __type_identity_t& __= a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } + + + multimap(initializer_list __l, const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) + { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } + + + template + multimap(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Pair_alloc_type(__a)) + { _M_t._M_insert_range_equal(__first, __last); } +# 272 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + multimap(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_range_equal(__first, __last); } +# 288 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_range_equal(__first, __last); } + + + + + + + + ~multimap() =3D default; +# 317 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap& + operator=3D(const multimap&) =3D default; + + + multimap& + operator=3D(multimap&&) =3D default; +# 335 "/usr/include/c++/13/bits/stl_multimap.h" 3 + multimap& + operator=3D(initializer_list __l) + { + _M_t._M_assign_equal(__l.begin(), __l.end()); + return *this; + } + + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_t.get_allocator()); } + + + + + + + + iterator + begin() noexcept + { return _M_t.begin(); } + + + + + + + const_iterator + begin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + end() noexcept + { return _M_t.end(); } + + + + + + + const_iterator + end() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() noexcept + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + rbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() noexcept + { return _M_t.rend(); } + + + + + + + const_reverse_iterator + rend() const noexcept + { return _M_t.rend(); } + + + + + + + + const_iterator + cbegin() const noexcept + { return _M_t.begin(); } + + + + + + + const_iterator + cend() const noexcept + { return _M_t.end(); } + + + + + + + const_reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + crend() const noexcept + { return _M_t.rend(); } + + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_t.empty(); } + + + size_type + size() const noexcept + { return _M_t.size(); } + + + size_type + max_size() const noexcept + { return _M_t.max_size(); } +# 493 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + iterator + emplace(_Args&&... __args) + { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } +# 520 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_equal(__pos, + std::forward<_Args>(__args)...); + } +# 542 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + insert(const value_type& __x) + { return _M_t._M_insert_equal(__x); } + + + + + iterator + insert(value_type&& __x) + { return _M_t._M_insert_equal(std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(_Pair&& __x) + { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); } +# 581 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + + insert(const_iterator __position, const value_type& __x) + + + + { return _M_t._M_insert_equal_(__position, __x); } + + + + + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_equal_(__position, std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(const_iterator __position, _Pair&& __x) + { + return _M_t._M_emplace_hint_equal(__position, + std::forward<_Pair>(__x)); + } +# 615 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_range_equal(__first, __last); } +# 628 "/usr/include/c++/13/bits/stl_multimap.h" 3 + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos !=3D end())) __bui= ltin_unreachable(); } while (false); + return _M_t.extract(__pos); + } + + + node_type + extract(const key_type& __x) + { return _M_t.extract(__x); } + + + iterator + insert(node_type&& __nh) + { return _M_t._M_reinsert_node_equal(std::move(__nh)); } + + + iterator + insert(const_iterator __hint, node_type&& __nh) + { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); } + + template + friend struct std::_Rb_tree_merge_helper; + + template + void + merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source) + { merge(__source); } +# 705 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } + + + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +# 742 "/usr/include/c++/13/bits/stl_multimap.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 763 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +# 800 "/usr/include/c++/13/bits/stl_multimap.h" 3 + void + swap(multimap& __x) + noexcept(__is_nothrow_swappable<_Compare>::value) + { _M_t.swap(__x._M_t); } + + + + + + + + void + clear() noexcept + { _M_t.clear(); } + + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + + + + + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } +# 846 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x)) + { return _M_t._M_find_tr(__x); } +# 870 "/usr/include/c++/13/bits/stl_multimap.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x)) + { return _M_t._M_find_tr(__x); } +# 888 "/usr/include/c++/13/bits/stl_multimap.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.count(__x); } + + + template + auto + count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) + { return _M_t._M_count_tr(__x); } +# 931 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) + { return iterator(_M_t._M_lower_bound_tr(__x)); } +# 956 "/usr/include/c++/13/bits/stl_multimap.h" 3 + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) const + -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) + { return const_iterator(_M_t._M_lower_bound_tr(__x)); } +# 976 "/usr/include/c++/13/bits/stl_multimap.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return iterator(_M_t._M_upper_bound_tr(__x)); } +# 996 "/usr/include/c++/13/bits/stl_multimap.h" 3 + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) const + -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x))) + { return const_iterator(_M_t._M_upper_bound_tr(__x)); } +# 1023 "/usr/include/c++/13/bits/stl_multimap.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } +# 1050 "/usr/include/c++/13/bits/stl_multimap.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) const + -> decltype(pair( + _M_t._M_equal_range_tr(__x))) + { + return pair( + _M_t._M_equal_range_tr(__x)); + } + + + + template + friend bool + operator=3D=3D(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + + + + + + + + template + friend bool + operator<(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + + }; + + + + template>, + typename _Allocator =3D allocator<__iter_to_alloc_t<_InputIterator>>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + multimap(_InputIterator, _InputIterator, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, + _Compare, _Allocator>; + + template, + typename _Allocator =3D allocator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + multimap(initializer_list>, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> multimap<_Key, _Tp, _Compare, _Allocator>; + + template, + typename =3D _RequireAllocator<_Allocator>> + multimap(_InputIterator, _InputIterator, _Allocator) + -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, + less<__iter_key_t<_InputIterator>>, _Allocator>; + + template> + multimap(initializer_list>, _Allocator) + -> multimap<_Key, _Tp, less<_Key>, _Allocator>; +# 1130 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + inline bool + operator=3D=3D(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t =3D=3D __y._M_t; } +# 1168 "/usr/include/c++/13/bits/stl_multimap.h" 3 + template + inline bool + operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=3D(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=3D(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=3D(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + + template + inline void + swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x, + multimap<_Key, _Tp, _Compare, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + + template + struct + _Rb_tree_merge_helper, + _Cmp2> + { + private: + friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>; + + static auto& + _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map) + { return __map._M_t; } + + static auto& + _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map) + { return __map._M_t; } + }; + + + +} +# 65 "/usr/include/c++/13/map" 2 3 +# 74 "/usr/include/c++/13/map" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr + { + template> + using map + =3D std::map<_Key, _Tp, _Cmp, + polymorphic_allocator>>; + template> + using multimap + =3D std::multimap<_Key, _Tp, _Cmp, + polymorphic_allocator>>; + } + +} +# 63 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 +# 1 "/usr/include/c++/13/set" 1 3 4 +# 58 "/usr/include/c++/13/set" 3 4 +=20=20=20=20=20=20=20 +# 59 "/usr/include/c++/13/set" 3 + + + + +# 1 "/usr/include/c++/13/bits/stl_set.h" 1 3 +# 64 "/usr/include/c++/13/bits/stl_set.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class multiset; +# 92 "/usr/include/c++/13/bits/stl_set.h" 3 + template, + typename _Alloc =3D std::allocator<_Key> > + class set + { +# 108 "/usr/include/c++/13/bits/stl_set.h" 3 + static_assert(is_same::type, _Key>::value, + "std::set must have a non-const, non-volatile value_type"); + + + + + + + public: + + + + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Alloc allocator_type; + + + private: + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Key>::other _Key_alloc_type; + + typedef _Rb_tree, + key_compare, _Key_alloc_type> _Rep_type; + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; + + public: + + + typedef typename _Alloc_traits::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 typename _Rep_type::const_iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::const_reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_ite= rator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + + + + using node_type =3D typename _Rep_type::node_type; + using insert_return_type =3D typename _Rep_type::insert_return_type; +# 167 "/usr/include/c++/13/bits/stl_set.h" 3 + set() =3D default; + + + + + + + + explicit + set(const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) { } +# 190 "/usr/include/c++/13/bits/stl_set.h" 3 + template + set(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_range_unique(__first, __last); } +# 207 "/usr/include/c++/13/bits/stl_set.h" 3 + template + set(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_range_unique(__first, __last); } +# 223 "/usr/include/c++/13/bits/stl_set.h" 3 + set(const set&) =3D default; + + + + + + + + set(set&&) =3D default; +# 243 "/usr/include/c++/13/bits/stl_set.h" 3 + set(initializer_list __l, + const _Compare& __comp =3D _Compare(), + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } + + + explicit + set(const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) { } + + + set(const set& __x, const __type_identity_t& __a) + : _M_t(__x._M_t, _Key_alloc_type(__a)) { } + + + set(set&& __x, const __type_identity_t& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { } + + + set(initializer_list __l, const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) + { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } + + + template + set(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) + { _M_t._M_insert_range_unique(__first, __last); } + + + + + + + ~set() =3D default; +# 297 "/usr/include/c++/13/bits/stl_set.h" 3 + set& + operator=3D(const set&) =3D default; + + + set& + operator=3D(set&&) =3D default; +# 315 "/usr/include/c++/13/bits/stl_set.h" 3 + set& + operator=3D(initializer_list __l) + { + _M_t._M_assign_unique(__l.begin(), __l.end()); + return *this; + } + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + value_compare + value_comp() const + { return _M_t.key_comp(); } + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_t.get_allocator()); } + + + + + + + iterator + begin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + end() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() const noexcept + { return _M_t.rend(); } + + + + + + + + iterator + cbegin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + cend() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + crend() const noexcept + { return _M_t.rend(); } + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_t.empty(); } + + + size_type + size() const noexcept + { return _M_t.size(); } + + + size_type + max_size() const noexcept + { return _M_t.max_size(); } +# 440 "/usr/include/c++/13/bits/stl_set.h" 3 + void + swap(set& __x) + noexcept(__is_nothrow_swappable<_Compare>::value) + { _M_t.swap(__x._M_t); } +# 460 "/usr/include/c++/13/bits/stl_set.h" 3 + template + std::pair + emplace(_Args&&... __args) + { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); } +# 486 "/usr/include/c++/13/bits/stl_set.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_unique(__pos, + std::forward<_Args>(__args)...); + } +# 508 "/usr/include/c++/13/bits/stl_set.h" 3 + std::pair + insert(const value_type& __x) + { + std::pair __p =3D + _M_t._M_insert_unique(__x); + return std::pair(__p.first, __p.second); + } + + + std::pair + insert(value_type&& __x) + { + std::pair __p =3D + _M_t._M_insert_unique(std::move(__x)); + return std::pair(__p.first, __p.second); + } +# 545 "/usr/include/c++/13/bits/stl_set.h" 3 + iterator + insert(const_iterator __position, const value_type& __x) + { return _M_t._M_insert_unique_(__position, __x); } + + + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_unique_(__position, std::move(__x)); } +# 564 "/usr/include/c++/13/bits/stl_set.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_range_unique(__first, __last); } +# 577 "/usr/include/c++/13/bits/stl_set.h" 3 + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos !=3D end())) __bui= ltin_unreachable(); } while (false); + return _M_t.extract(__pos); + } + + + node_type + extract(const key_type& __x) + { return _M_t.extract(__x); } + + + insert_return_type + insert(node_type&& __nh) + { return _M_t._M_reinsert_node_unique(std::move(__nh)); } + + + iterator + insert(const_iterator __hint, node_type&& __nh) + { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh));= } + + template + friend struct std::_Rb_tree_merge_helper; + + template + void + merge(set<_Key, _Compare1, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(set<_Key, _Compare1, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(multiset<_Key, _Compare1, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(multiset<_Key, _Compare1, _Alloc>&& __source) + { merge(__source); } +# 652 "/usr/include/c++/13/bits/stl_set.h" 3 + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } +# 683 "/usr/include/c++/13/bits/stl_set.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 704 "/usr/include/c++/13/bits/stl_set.h" 3 + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +# 732 "/usr/include/c++/13/bits/stl_set.h" 3 + void + clear() noexcept + { _M_t.clear(); } +# 747 "/usr/include/c++/13/bits/stl_set.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.find(__x) =3D=3D _M_t.end() ? 0 : 1; } + + + template + auto + count(const _Kt& __x) const + -> decltype(_M_t._M_count_tr(__x)) + { return _M_t._M_count_tr(__x); } +# 793 "/usr/include/c++/13/bits/stl_set.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) + -> decltype(iterator{_M_t._M_find_tr(__x)}) + { return iterator{_M_t._M_find_tr(__x)}; } + + template + auto + find(const _Kt& __x) const + -> decltype(const_iterator{_M_t._M_find_tr(__x)}) + { return const_iterator{_M_t._M_find_tr(__x)}; } +# 828 "/usr/include/c++/13/bits/stl_set.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) + { return iterator(_M_t._M_lower_bound_tr(__x)); } + + template + auto + lower_bound(const _Kt& __x) const + -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) + { return const_iterator(_M_t._M_lower_bound_tr(__x)); } +# 858 "/usr/include/c++/13/bits/stl_set.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return iterator(_M_t._M_upper_bound_tr(__x)); } + + template + auto + upper_bound(const _Kt& __x) const + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return const_iterator(_M_t._M_upper_bound_tr(__x)); } +# 897 "/usr/include/c++/13/bits/stl_set.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } + + template + auto + equal_range(const _Kt& __x) const + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } + + + + template + friend bool + operator=3D=3D(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); + + + + + + + template + friend bool + operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); + + }; + + + + template::value_type>, + typename _Allocator =3D + allocator::value_type>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + set(_InputIterator, _InputIterator, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> set::value_type, + _Compare, _Allocator>; + + template, + typename _Allocator =3D allocator<_Key>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + set(initializer_list<_Key>, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> set<_Key, _Compare, _Allocator>; + + template, + typename =3D _RequireAllocator<_Allocator>> + set(_InputIterator, _InputIterator, _Allocator) + -> set::value_type, + less::value_type>, + _Allocator>; + + template> + set(initializer_list<_Key>, _Allocator) + -> set<_Key, less<_Key>, _Allocator>; +# 983 "/usr/include/c++/13/bits/stl_set.h" 3 + template + inline bool + operator=3D=3D(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __x._M_t =3D=3D __y._M_t; } +# 1021 "/usr/include/c++/13/bits/stl_set.h" 3 + template + inline bool + operator<(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=3D(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator>(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=3D(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=3D(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + + template + inline void + swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __= y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + + template + struct + _Rb_tree_merge_helper, _Cmp2> + { + private: + friend class std::set<_Val, _Cmp1, _Alloc>; + + static auto& + _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set) + { return __set._M_t; } + + static auto& + _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set) + { return __set._M_t; } + }; + + + +} +# 64 "/usr/include/c++/13/set" 2 3 +# 1 "/usr/include/c++/13/bits/stl_multiset.h" 1 3 +# 64 "/usr/include/c++/13/bits/stl_multiset.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class set; +# 94 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template , + typename _Alloc =3D std::allocator<_Key> > + class multiset + { +# 110 "/usr/include/c++/13/bits/stl_multiset.h" 3 + static_assert(is_same::type, _Key>::value, + "std::multiset must have a non-const, non-volatile value_type"); + + + + + + + public: + + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Alloc allocator_type; + + private: + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Key>::other _Key_alloc_type; + + typedef _Rb_tree, + key_compare, _Key_alloc_type> _Rep_type; + + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; + + public: + typedef typename _Alloc_traits::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 typename _Rep_type::const_iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::const_reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_ite= rator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + + + using node_type =3D typename _Rep_type::node_type; +# 164 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset() =3D default; + + + + + + + + explicit + multiset(const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) { } +# 186 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + multiset(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_range_equal(__first, __last); } +# 202 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_range_equal(__first, __last); } +# 218 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset(const multiset&) =3D default; +# 227 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset(multiset&&) =3D default; +# 239 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset(initializer_list __l, + const _Compare& __comp =3D _Compare(), + const allocator_type& __a =3D allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } + + + explicit + multiset(const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) { } + + + multiset(const multiset& __m, + const __type_identity_t& __a) + : _M_t(__m._M_t, _Key_alloc_type(__a)) { } + + + multiset(multiset&& __m, const __type_identity_t& __= a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { } + + + multiset(initializer_list __l, const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) + { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } + + + template + multiset(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Key_alloc_type(__a)) + { _M_t._M_insert_range_equal(__first, __last); } + + + + + + + ~multiset() =3D default; +# 294 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset& + operator=3D(const multiset&) =3D default; + + + multiset& + operator=3D(multiset&&) =3D default; +# 312 "/usr/include/c++/13/bits/stl_multiset.h" 3 + multiset& + operator=3D(initializer_list __l) + { + _M_t._M_assign_equal(__l.begin(), __l.end()); + return *this; + } + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + value_compare + value_comp() const + { return _M_t.key_comp(); } + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_t.get_allocator()); } + + + + + + + iterator + begin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + end() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() const noexcept + { return _M_t.rend(); } + + + + + + + + iterator + cbegin() const noexcept + { return _M_t.begin(); } + + + + + + + iterator + cend() const noexcept + { return _M_t.end(); } + + + + + + + reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + crend() const noexcept + { return _M_t.rend(); } + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_t.empty(); } + + + size_type + size() const noexcept + { return _M_t.size(); } + + + size_type + max_size() const noexcept + { return _M_t.max_size(); } +# 437 "/usr/include/c++/13/bits/stl_multiset.h" 3 + void + swap(multiset& __x) + noexcept(__is_nothrow_swappable<_Compare>::value) + { _M_t.swap(__x._M_t); } +# 456 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + iterator + emplace(_Args&&... __args) + { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } +# 482 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_equal(__pos, + std::forward<_Args>(__args)...); + } +# 502 "/usr/include/c++/13/bits/stl_multiset.h" 3 + iterator + insert(const value_type& __x) + { return _M_t._M_insert_equal(__x); } + + + iterator + insert(value_type&& __x) + { return _M_t._M_insert_equal(std::move(__x)); } +# 532 "/usr/include/c++/13/bits/stl_multiset.h" 3 + iterator + insert(const_iterator __position, const value_type& __x) + { return _M_t._M_insert_equal_(__position, __x); } + + + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_equal_(__position, std::move(__x)); } +# 550 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_range_equal(__first, __last); } +# 563 "/usr/include/c++/13/bits/stl_multiset.h" 3 + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos !=3D end())) __bui= ltin_unreachable(); } while (false); + return _M_t.extract(__pos); + } + + + node_type + extract(const key_type& __x) + { return _M_t.extract(__x); } + + + iterator + insert(node_type&& __nh) + { return _M_t._M_reinsert_node_equal(std::move(__nh)); } + + + iterator + insert(const_iterator __hint, node_type&& __nh) + { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); } + + template + friend struct std::_Rb_tree_merge_helper; + + template + void + merge(multiset<_Key, _Compare1, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(multiset<_Key, _Compare1, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(set<_Key, _Compare1, _Alloc>& __source) + { + using _Merge_helper =3D _Rb_tree_merge_helper; + _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); + } + + template + void + merge(set<_Key, _Compare1, _Alloc>&& __source) + { merge(__source); } +# 638 "/usr/include/c++/13/bits/stl_multiset.h" 3 + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } +# 669 "/usr/include/c++/13/bits/stl_multiset.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 690 "/usr/include/c++/13/bits/stl_multiset.h" 3 + __attribute ((__abi_tag__ ("cxx11"))) + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +# 718 "/usr/include/c++/13/bits/stl_multiset.h" 3 + void + clear() noexcept + { _M_t.clear(); } +# 730 "/usr/include/c++/13/bits/stl_multiset.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.count(__x); } + + + template + auto + count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) + { return _M_t._M_count_tr(__x); } +# 775 "/usr/include/c++/13/bits/stl_multiset.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + + template + auto + find(const _Kt& __x) + -> decltype(iterator{_M_t._M_find_tr(__x)}) + { return iterator{_M_t._M_find_tr(__x)}; } + + template + auto + find(const _Kt& __x) const + -> decltype(const_iterator{_M_t._M_find_tr(__x)}) + { return const_iterator{_M_t._M_find_tr(__x)}; } +# 810 "/usr/include/c++/13/bits/stl_multiset.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + + template + auto + lower_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) + { return iterator(_M_t._M_lower_bound_tr(__x)); } + + template + auto + lower_bound(const _Kt& __x) const + -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) + { return iterator(_M_t._M_lower_bound_tr(__x)); } +# 840 "/usr/include/c++/13/bits/stl_multiset.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + + template + auto + upper_bound(const _Kt& __x) + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return iterator(_M_t._M_upper_bound_tr(__x)); } + + template + auto + upper_bound(const _Kt& __x) const + -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) + { return iterator(_M_t._M_upper_bound_tr(__x)); } +# 879 "/usr/include/c++/13/bits/stl_multiset.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + + template + auto + equal_range(const _Kt& __x) + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } + + template + auto + equal_range(const _Kt& __x) const + -> decltype(pair(_M_t._M_equal_range_tr(__x))) + { return pair(_M_t._M_equal_range_tr(__x)); } + + + + template + friend bool + operator=3D=3D(const multiset<_K1, _C1, _A1>&, + const multiset<_K1, _C1, _A1>&); + + + + + + + + template + friend bool + operator< (const multiset<_K1, _C1, _A1>&, + const multiset<_K1, _C1, _A1>&); + + }; + + + + template::value_type>, + typename _Allocator =3D + allocator::value_type>, + typename =3D _RequireInputIter<_InputIterator>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + multiset(_InputIterator, _InputIterator, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> multiset::value_type, + _Compare, _Allocator>; + + template, + typename _Allocator =3D allocator<_Key>, + typename =3D _RequireNotAllocator<_Compare>, + typename =3D _RequireAllocator<_Allocator>> + multiset(initializer_list<_Key>, + _Compare =3D _Compare(), _Allocator =3D _Allocator()) + -> multiset<_Key, _Compare, _Allocator>; + + template, + typename =3D _RequireAllocator<_Allocator>> + multiset(_InputIterator, _InputIterator, _Allocator) + -> multiset::value_type, + less::value_type>, + _Allocator>; + + template> + multiset(initializer_list<_Key>, _Allocator) + -> multiset<_Key, less<_Key>, _Allocator>; +# 970 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + inline bool + operator=3D=3D(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return __x._M_t =3D=3D __y._M_t; } +# 1008 "/usr/include/c++/13/bits/stl_multiset.h" 3 + template + inline bool + operator<(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=3D(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__x =3D=3D __y); } + + + template + inline bool + operator>(const multiset<_Key,_Compare,_Alloc>& __x, + const multiset<_Key,_Compare,_Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=3D(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=3D(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + + template + inline void + swap(multiset<_Key, _Compare, _Alloc>& __x, + multiset<_Key, _Compare, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + + template + struct + _Rb_tree_merge_helper, + _Cmp2> + { + private: + friend class std::multiset<_Val, _Cmp1, _Alloc>; + + static auto& + _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set) + { return __set._M_t; } + + static auto& + _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set) + { return __set._M_t; } + }; + + + +} +# 65 "/usr/include/c++/13/set" 2 3 +# 74 "/usr/include/c++/13/set" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr + { + template> + using set =3D std::set<_Key, _Cmp, polymorphic_allocator<_Key>>; + template> + using multiset =3D std::multiset<_Key, _Cmp, polymorphic_allocator<_= Key>>; + } + +} +# 64 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 + + + + + +# 1 "/usr/include/gtest/internal/gtest-filepath.h" 1 3 4 +# 45 "/usr/include/gtest/internal/gtest-filepath.h" 3 4 +# 1 "/usr/include/gtest/internal/gtest-string.h" 1 3 4 +# 58 "/usr/include/gtest/internal/gtest-string.h" 3 4 +namespace testing { +namespace internal { + + +class __attribute__((visibility("default"))) String { + public: +# 73 "/usr/include/gtest/internal/gtest-string.h" 3 4 + static const char* CloneCString(const char* c_str); +# 107 "/usr/include/gtest/internal/gtest-string.h" 3 4 + static bool CStringEquals(const char* lhs, const char* rhs); + + + + + + static std::string ShowWideCString(const wchar_t* wide_c_str); + + + + + + + + static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); + + + + + + + + static bool CaseInsensitiveCStringEquals(const char* lhs, const char* rh= s); +# 143 "/usr/include/gtest/internal/gtest-string.h" 3 4 + static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, + const wchar_t* rhs); + + + + static bool EndsWithCaseInsensitive(const std::string& str, + const std::string& suffix); + + + static std::string FormatIntWidth2(int value); + + + static std::string FormatIntWidthN(int value, int width); + + + static std::string FormatHexInt(int value); + + + static std::string FormatHexUInt32(uint32_t value); + + + static std::string FormatByte(unsigned char value); + + private: + String(); +}; + + + +__attribute__((visibility("default"))) std::string StringStreamToString(::= std::stringstream* stream); + +} +} +# 46 "/usr/include/gtest/internal/gtest-filepath.h" 2 3 4 + + + + +namespace testing { +namespace internal { +# 64 "/usr/include/gtest/internal/gtest-filepath.h" 3 4 +class __attribute__((visibility("default"))) FilePath { + public: + FilePath() : pathname_("") {} + FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {} + + explicit FilePath(const std::string& pathname) : pathname_(pathname) { + Normalize(); + } + + FilePath& operator=3D(const FilePath& rhs) { + Set(rhs); + return *this; + } + + void Set(const FilePath& rhs) { pathname_ =3D rhs.pathname_; } + + const std::string& string() const { return pathname_; } + const char* c_str() const { return pathname_.c_str(); } + + + static FilePath GetCurrentDir(); + + + + + + static FilePath MakeFileName(const FilePath& directory, + const FilePath& base_name, int number, + const char* extension); + + + + + static FilePath ConcatPaths(const FilePath& directory, + const FilePath& relative_path); +# 108 "/usr/include/gtest/internal/gtest-filepath.h" 3 4 + static FilePath GenerateUniqueFileName(const FilePath& directory, + const FilePath& base_name, + const char* extension); + + + bool IsEmpty() const { return pathname_.empty(); } + + + + + FilePath RemoveTrailingPathSeparator() const; + + + + + + + + FilePath RemoveDirectoryName() const; + + + + + + + + FilePath RemoveFileName() const; + + + + + + FilePath RemoveExtension(const char* extension) const; + + + + + + bool CreateDirectoriesRecursively() const; + + + + + + bool CreateFolder() const; + + + + bool FileOrDirectoryExists() const; + + + + bool DirectoryExists() const; + + + + + bool IsDirectory() const; + + + + bool IsRootDirectory() const; + + + bool IsAbsolutePath() const; + + private: +# 195 "/usr/include/gtest/internal/gtest-filepath.h" 3 4 + void Normalize(); + + + + + const char* FindLastPathSeparator() const; + + std::string pathname_; +}; + +} +} + + +# 70 "/usr/include/gtest/internal/gtest-internal.h" 2 3 4 + +# 1 "/usr/include/gtest/internal/gtest-type-util.h" 1 3 4 +# 45 "/usr/include/gtest/internal/gtest-type-util.h" 3 4 +# 1 "/usr/include/c++/13/cxxabi.h" 1 3 4 +# 44 "/usr/include/c++/13/cxxabi.h" 3 4 +=20=20=20=20=20=20=20 +# 45 "/usr/include/c++/13/cxxabi.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/gcc/riscv64-linux-gnu/13/include/stddef.h" 1 3 4 +# 49 "/usr/include/c++/13/cxxabi.h" 2 3 + +# 1 "/usr/include/riscv64-linux-gnu/c++/13/bits/cxxabi_tweaks.h" 1 3 +# 34 "/usr/include/riscv64-linux-gnu/c++/13/bits/cxxabi_tweaks.h" 3 +namespace __cxxabiv1 +{ + extern "C" + { +# 46 "/usr/include/riscv64-linux-gnu/c++/13/bits/cxxabi_tweaks.h" 3 + __extension__ typedef int __guard __attribute__((mode (__DI__))); + + + typedef void __cxa_vec_ctor_return_type; + + + typedef void __cxa_cdtor_return_type; + + + } +} +# 51 "/usr/include/c++/13/cxxabi.h" 2 3 + + + + +namespace __cxxabiv1 +{ + extern "C" + { + + + typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *); + + + void* + __cxa_vec_new(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor); + + void* + __cxa_vec_new2(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), + void (*__dealloc) (void*)); + + void* + __cxa_vec_new3(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), + void (*__dealloc) (void*, size_t)); + + + __cxa_vec_ctor_return_type + __cxa_vec_ctor(void* __array_address, size_t __element_count, + size_t __element_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor); + + __cxa_vec_ctor_return_type + __cxa_vec_cctor(void* __dest_array, void* __src_array, + size_t __element_count, size_t __element_size, + __cxa_cdtor_return_type (*__constructor) (void*, void*), + __cxa_cdtor_type __destructor); + + + void + __cxa_vec_dtor(void* __array_address, size_t __element_count, + size_t __element_size, __cxa_cdtor_type __destructor); + + void + __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t = __s, + __cxa_cdtor_type __destructor) noexcept; + + + void + __cxa_vec_delete(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor); + + void + __cxa_vec_delete2(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor, + void (*__dealloc) (void*)); + + void + __cxa_vec_delete3(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor, + void (*__dealloc) (void*, size_t)); + + int + __cxa_guard_acquire(__guard*); + + void + __cxa_guard_release(__guard*) noexcept; + + void + __cxa_guard_abort(__guard*) noexcept; + + + int + + __cxa_atexit(void ( *)(void*), void*, void*) noexcept; + + + + + void + __cxa_finalize(void*); + + + int + + __cxa_thread_atexit(void ( *)(void*), void*, void *) noexcept; + + + + + + void + __cxa_pure_virtual(void) __attribute__ ((__noreturn__)); + + void + __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); + + + void + __cxa_bad_cast() __attribute__((__noreturn__)); + + void + __cxa_bad_typeid() __attribute__((__noreturn__)); + + void + __cxa_throw_bad_array_new_length() __attribute__((__noreturn__)); +# 203 "/usr/include/c++/13/cxxabi.h" 3 + char* + __cxa_demangle(const char* __mangled_name, char* __output_buffer, + size_t* __length, int* __status); + + + } +} + + + + + + +namespace __cxxabiv1 +{ + + class __fundamental_type_info : public std::type_info + { + public: + explicit + __fundamental_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__fundamental_type_info(); + }; + + + class __array_type_info : public std::type_info + { + public: + explicit + __array_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__array_type_info(); + }; + + + class __function_type_info : public std::type_info + { + public: + explicit + __function_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__function_type_info(); + + protected: + + virtual bool + __is_function_p() const; + }; + + + class __enum_type_info : public std::type_info + { + public: + explicit + __enum_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__enum_type_info(); + }; + + + class __pbase_type_info : public std::type_info + { + public: + unsigned int __flags; + const std::type_info* __pointee; + + explicit + __pbase_type_info(const char* __n, int __quals, + const std::type_info* __type) + : std::type_info(__n), __flags(__quals), __pointee(__type) + { } + + virtual + ~__pbase_type_info(); + + + enum __masks + { + __const_mask =3D 0x1, + __volatile_mask =3D 0x2, + __restrict_mask =3D 0x4, + __incomplete_mask =3D 0x8, + __incomplete_class_mask =3D 0x10, + __transaction_safe_mask =3D 0x20, + __noexcept_mask =3D 0x40 + }; + + protected: + __pbase_type_info(const __pbase_type_info&); + + __pbase_type_info& + operator=3D(const __pbase_type_info&); + + + virtual bool + __do_catch(const std::type_info* __thr_type, void** __thr_obj, + unsigned int __outer) const; + + inline virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + inline bool __pbase_type_info:: + __pointer_catch (const __pbase_type_info *thrown_type, + void **thr_obj, + unsigned outer) const + { + return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer += 2); + } + + + class __pointer_type_info : public __pbase_type_info + { + public: + explicit + __pointer_type_info(const char* __n, int __quals, + const std::type_info* __type) + : __pbase_type_info (__n, __quals, __type) { } + + + virtual + ~__pointer_type_info(); + + protected: + + virtual bool + __is_pointer_p() const; + + virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + class __class_type_info; + + + class __pointer_to_member_type_info : public __pbase_type_info + { + public: + __class_type_info* __context; + + explicit + __pointer_to_member_type_info(const char* __n, int __quals, + const std::type_info* __type, + __class_type_info* __klass) + : __pbase_type_info(__n, __quals, __type), __context(__klass) { } + + virtual + ~__pointer_to_member_type_info(); + + protected: + __pointer_to_member_type_info(const __pointer_to_member_type_info&); + + __pointer_to_member_type_info& + operator=3D(const __pointer_to_member_type_info&); + + + virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + + class __base_class_type_info + { + public: + const __class_type_info* __base_type; + + + + long __offset_flags; + + + enum __offset_flags_masks + { + __virtual_mask =3D 0x1, + __public_mask =3D 0x2, + __hwm_bit =3D 2, + __offset_shift =3D 8 + }; + + + bool + __is_virtual_p() const + { return __offset_flags & __virtual_mask; } + + bool + __is_public_p() const + { return __offset_flags & __public_mask; } + + ptrdiff_t + __offset() const + { + + + + return static_cast(__offset_flags) >> __offset_shift; + } + }; + + + class __class_type_info : public std::type_info + { + public: + explicit + __class_type_info (const char *__n) : type_info(__n) { } + + virtual + ~__class_type_info (); + + + + + + + enum __sub_kind + { + + __unknown =3D 0, + + + + __not_contained, + + + __contained_ambig, + + + __contained_virtual_mask =3D __base_class_type_info::__virtual_mask, + + + __contained_public_mask =3D __base_class_type_info::__public_mask, + + + __contained_mask =3D 1 << __base_class_type_info::__hwm_bit, + + __contained_private =3D __contained_mask, + __contained_public =3D __contained_mask | __contained_public_mask + }; + + struct __upcast_result; + struct __dyncast_result; + + protected: + + virtual bool + __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) cons= t; + + virtual bool + __do_catch(const type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + + public: + + + virtual bool + __do_upcast(const __class_type_info* __dst, const void* __obj, + __upcast_result& __restrict __result) const; + + + + + + + + inline __sub_kind + __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; +# 486 "/usr/include/c++/13/cxxabi.h" 3 + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + + + + + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; + }; + + + class __si_class_type_info : public __class_type_info + { + public: + const __class_type_info* __base_type; + + explicit + __si_class_type_info(const char *__n, const __class_type_info *__base) + : __class_type_info(__n), __base_type(__base) { } + + virtual + ~__si_class_type_info(); + + protected: + __si_class_type_info(const __si_class_type_info&); + + __si_class_type_info& + operator=3D(const __si_class_type_info&); + + + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __sub_ptr) const; + + virtual bool + __do_upcast(const __class_type_info*__dst, const void*__obj, + __upcast_result& __restrict __result) const; + }; + + + class __vmi_class_type_info : public __class_type_info + { + public: + unsigned int __flags; + unsigned int __base_count; + + + + + __base_class_type_info __base_info[1]; + + explicit + __vmi_class_type_info(const char* __n, int ___flags) + : __class_type_info(__n), __flags(___flags), __base_count(0) { } + + virtual + ~__vmi_class_type_info(); + + + enum __flags_masks + { + __non_diamond_repeat_mask =3D 0x1, + __diamond_shaped_mask =3D 0x2, + __flags_unknown_mask =3D 0x10 + }; + + protected: + + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; + + virtual bool + __do_upcast(const __class_type_info* __dst, const void* __obj, + __upcast_result& __restrict __result) const; + }; + + + struct __cxa_exception; + struct __cxa_refcounted_exception; + struct __cxa_dependent_exception; + struct __cxa_eh_globals; + + extern "C" + { +# 599 "/usr/include/c++/13/cxxabi.h" 3 + void* + __dynamic_cast(const void* __src_ptr, + const __class_type_info* __src_type, + const __class_type_info* __dst_type, + ptrdiff_t __src2dst); +# 612 "/usr/include/c++/13/cxxabi.h" 3 + __cxa_eh_globals* + __cxa_get_globals() noexcept __attribute__ ((__const__)); + + __cxa_eh_globals* + __cxa_get_globals_fast() noexcept __attribute__ ((__const__)); + + + void + __cxa_free_exception(void*) noexcept; + + + void + __cxa_throw(void*, std::type_info*, void ( *) (void *)) + __attribute__((__noreturn__)); + + + void* + __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__)); + + void* + __cxa_begin_catch(void*) noexcept; + + void + __cxa_end_catch(); + + void + __cxa_rethrow() __attribute__((__noreturn__)); + + + + std::type_info* + __cxa_current_exception_type() noexcept __attribute__ ((__pure__)); + + + + + __cxa_dependent_exception* + __cxa_allocate_dependent_exception() noexcept; + + + void + __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept; + + } + + + + class __foreign_exception + { + virtual ~__foreign_exception() throw(); + virtual void __pure_dummy() =3D 0; + }; + +} +# 687 "/usr/include/c++/13/cxxabi.h" 3 +namespace abi =3D __cxxabiv1; + +namespace __gnu_cxx +{ +# 704 "/usr/include/c++/13/cxxabi.h" 3 + class recursive_init_error: public std::exception + { + public: + recursive_init_error() noexcept; + virtual ~recursive_init_error() noexcept; + }; +} + + +#pragma GCC visibility pop +# 46 "/usr/include/gtest/internal/gtest-type-util.h" 2 3 4 + + + + +namespace testing { +namespace internal { + + + + + +inline std::string CanonicalizeForStdLibVersioning(std::string s) { + static const char prefix[] =3D "std::__"; + if (s.compare(0, strlen(prefix), prefix) =3D=3D 0) { + std::string::size_type end =3D s.find("::", strlen(prefix)); + if (end !=3D s.npos) { + + s.erase(strlen("std"), end - strlen("std")); + } + } + return s; +} + + + +inline std::string GetTypeName(const std::type_info& type) { + const char* const name =3D type.name(); + + int status =3D 0; + + + + using abi::__cxa_demangle; + + char* const readable_name =3D __cxa_demangle(name, nullptr, nullptr, &st= atus); + const std::string name_str(status =3D=3D 0 ? readable_name : name); + free(readable_name); + return CanonicalizeForStdLibVersioning(name_str); + + + +} + + + + + + +template +std::string GetTypeName() { + + return GetTypeName(typeid(T)); + + + +} + + +struct None {}; +# 118 "/usr/include/gtest/internal/gtest-type-util.h" 3 4 +template