Thanks for using Compiler Explorer
Sponsors
Jakt
C++
Ada
Analysis
Android Java
Android Kotlin
Assembly
C
C3
Carbon
C++ (Circle)
CIRCT
Clean
CMake
CMakeScript
COBOL
C++ for OpenCL
MLIR
Cppx
Cppx-Blue
Cppx-Gold
Cpp2-cppfront
Crystal
C#
CUDA C++
D
Dart
Elixir
Erlang
Fortran
F#
Go
Haskell
HLSL
Hook
Hylo
ispc
Java
Julia
Kotlin
LLVM IR
LLVM MIR
Modula-2
Nim
Objective-C
Objective-C++
OCaml
OpenCL C
Pascal
Pony
Python
Racket
Ruby
Rust
Snowball
Scala
Solidity
Spice
Swift
LLVM TableGen
Toit
TypeScript Native
V
Vala
Visual Basic
WASM
Zig
Javascript
GIMPLE
c++ source #1
Output
Compile to binary object
Link to binary
Execute the code
Intel asm syntax
Demangle identifiers
Verbose demangling
Filters
Unused labels
Library functions
Directives
Comments
Horizontal whitespace
Debug intrinsics
Compiler
6502-c++ 11.1.0
ARM GCC 10.2.0
ARM GCC 10.3.0
ARM GCC 10.4.0
ARM GCC 10.5.0
ARM GCC 11.1.0
ARM GCC 11.2.0
ARM GCC 11.3.0
ARM GCC 11.4.0
ARM GCC 12.1.0
ARM GCC 12.2.0
ARM GCC 12.3.0
ARM GCC 12.4.0
ARM GCC 13.1.0
ARM GCC 13.2.0
ARM GCC 13.2.0 (unknown-eabi)
ARM GCC 13.3.0
ARM GCC 13.3.0 (unknown-eabi)
ARM GCC 14.1.0
ARM GCC 14.1.0 (unknown-eabi)
ARM GCC 14.2.0
ARM GCC 14.2.0 (unknown-eabi)
ARM GCC 4.5.4
ARM GCC 4.6.4
ARM GCC 5.4
ARM GCC 6.3.0
ARM GCC 6.4.0
ARM GCC 7.3.0
ARM GCC 7.5.0
ARM GCC 8.2.0
ARM GCC 8.5.0
ARM GCC 9.3.0
ARM GCC 9.4.0
ARM GCC 9.5.0
ARM GCC trunk
ARM gcc 10.2.1 (none)
ARM gcc 10.3.1 (2021.07 none)
ARM gcc 10.3.1 (2021.10 none)
ARM gcc 11.2.1 (none)
ARM gcc 5.4.1 (none)
ARM gcc 7.2.1 (none)
ARM gcc 8.2 (WinCE)
ARM gcc 8.3.1 (none)
ARM gcc 9.2.1 (none)
ARM msvc v19.0 (WINE)
ARM msvc v19.10 (WINE)
ARM msvc v19.14 (WINE)
ARM64 Morello gcc 10.1 Alpha 2
ARM64 gcc 10.2
ARM64 gcc 10.3
ARM64 gcc 10.4
ARM64 gcc 10.5.0
ARM64 gcc 11.1
ARM64 gcc 11.2
ARM64 gcc 11.3
ARM64 gcc 11.4.0
ARM64 gcc 12.1
ARM64 gcc 12.2.0
ARM64 gcc 12.3.0
ARM64 gcc 12.4.0
ARM64 gcc 13.1.0
ARM64 gcc 13.2.0
ARM64 gcc 13.3.0
ARM64 gcc 14.1.0
ARM64 gcc 14.2.0
ARM64 gcc 4.9.4
ARM64 gcc 5.4
ARM64 gcc 5.5.0
ARM64 gcc 6.3
ARM64 gcc 6.4
ARM64 gcc 7.3
ARM64 gcc 7.5
ARM64 gcc 8.2
ARM64 gcc 8.5
ARM64 gcc 9.3
ARM64 gcc 9.4
ARM64 gcc 9.5
ARM64 gcc trunk
ARM64 msvc v19.14 (WINE)
AVR gcc 10.3.0
AVR gcc 11.1.0
AVR gcc 12.1.0
AVR gcc 12.2.0
AVR gcc 12.3.0
AVR gcc 12.4.0
AVR gcc 13.1.0
AVR gcc 13.2.0
AVR gcc 13.3.0
AVR gcc 14.1.0
AVR gcc 14.2.0
AVR gcc 4.5.4
AVR gcc 4.6.4
AVR gcc 5.4.0
AVR gcc 9.2.0
AVR gcc 9.3.0
Arduino Mega (1.8.9)
Arduino Uno (1.8.9)
BPF clang (trunk)
BPF clang 13.0.0
BPF clang 14.0.0
BPF clang 15.0.0
BPF clang 16.0.0
BPF clang 17.0.1
BPF clang 18.1.0
BPF clang 19.1.0
BPF gcc 13.1.0
BPF gcc 13.2.0
BPF gcc 13.3.0
BPF gcc trunk
EDG (experimental reflection)
EDG 6.5
EDG 6.5 (GNU mode gcc 13)
EDG 6.6
EDG 6.6 (GNU mode gcc 13)
FRC 2019
FRC 2020
FRC 2023
HPPA gcc 14.2.0
KVX ACB 4.1.0 (GCC 7.5.0)
KVX ACB 4.1.0-cd1 (GCC 7.5.0)
KVX ACB 4.10.0 (GCC 10.3.1)
KVX ACB 4.11.1 (GCC 10.3.1)
KVX ACB 4.12.0 (GCC 11.3.0)
KVX ACB 4.2.0 (GCC 7.5.0)
KVX ACB 4.3.0 (GCC 7.5.0)
KVX ACB 4.4.0 (GCC 7.5.0)
KVX ACB 4.6.0 (GCC 9.4.1)
KVX ACB 4.8.0 (GCC 9.4.1)
KVX ACB 4.9.0 (GCC 9.4.1)
KVX ACB 5.0.0 (GCC 12.2.1)
LoongArch64 clang (trunk)
LoongArch64 clang 17.0.1
LoongArch64 clang 18.1.0
LoongArch64 clang 19.1.0
M68K gcc 13.1.0
M68K gcc 13.2.0
M68K gcc 13.3.0
M68K gcc 14.1.0
M68K gcc 14.2.0
M68k clang (trunk)
MRISC32 gcc (trunk)
MSP430 gcc 4.5.3
MSP430 gcc 5.3.0
MSP430 gcc 6.2.1
MinGW clang 14.0.3
MinGW clang 14.0.6
MinGW clang 15.0.7
MinGW clang 16.0.0
MinGW clang 16.0.2
MinGW gcc 11.3.0
MinGW gcc 12.1.0
MinGW gcc 12.2.0
MinGW gcc 13.1.0
RISC-V (32-bits) gcc (trunk)
RISC-V (32-bits) gcc 10.2.0
RISC-V (32-bits) gcc 10.3.0
RISC-V (32-bits) gcc 11.2.0
RISC-V (32-bits) gcc 11.3.0
RISC-V (32-bits) gcc 11.4.0
RISC-V (32-bits) gcc 12.1.0
RISC-V (32-bits) gcc 12.2.0
RISC-V (32-bits) gcc 12.3.0
RISC-V (32-bits) gcc 12.4.0
RISC-V (32-bits) gcc 13.1.0
RISC-V (32-bits) gcc 13.2.0
RISC-V (32-bits) gcc 13.3.0
RISC-V (32-bits) gcc 14.1.0
RISC-V (32-bits) gcc 14.2.0
RISC-V (32-bits) gcc 8.2.0
RISC-V (32-bits) gcc 8.5.0
RISC-V (32-bits) gcc 9.4.0
RISC-V (64-bits) gcc (trunk)
RISC-V (64-bits) gcc 10.2.0
RISC-V (64-bits) gcc 10.3.0
RISC-V (64-bits) gcc 11.2.0
RISC-V (64-bits) gcc 11.3.0
RISC-V (64-bits) gcc 11.4.0
RISC-V (64-bits) gcc 12.1.0
RISC-V (64-bits) gcc 12.2.0
RISC-V (64-bits) gcc 12.3.0
RISC-V (64-bits) gcc 12.4.0
RISC-V (64-bits) gcc 13.1.0
RISC-V (64-bits) gcc 13.2.0
RISC-V (64-bits) gcc 13.3.0
RISC-V (64-bits) gcc 14.1.0
RISC-V (64-bits) gcc 14.2.0
RISC-V (64-bits) gcc 8.2.0
RISC-V (64-bits) gcc 8.5.0
RISC-V (64-bits) gcc 9.4.0
RISC-V rv32gc clang (trunk)
RISC-V rv32gc clang 10.0.0
RISC-V rv32gc clang 10.0.1
RISC-V rv32gc clang 11.0.0
RISC-V rv32gc clang 11.0.1
RISC-V rv32gc clang 12.0.0
RISC-V rv32gc clang 12.0.1
RISC-V rv32gc clang 13.0.0
RISC-V rv32gc clang 13.0.1
RISC-V rv32gc clang 14.0.0
RISC-V rv32gc clang 15.0.0
RISC-V rv32gc clang 16.0.0
RISC-V rv32gc clang 17.0.1
RISC-V rv32gc clang 18.1.0
RISC-V rv32gc clang 19.1.0
RISC-V rv32gc clang 9.0.0
RISC-V rv32gc clang 9.0.1
RISC-V rv64gc clang (trunk)
RISC-V rv64gc clang 10.0.0
RISC-V rv64gc clang 10.0.1
RISC-V rv64gc clang 11.0.0
RISC-V rv64gc clang 11.0.1
RISC-V rv64gc clang 12.0.0
RISC-V rv64gc clang 12.0.1
RISC-V rv64gc clang 13.0.0
RISC-V rv64gc clang 13.0.1
RISC-V rv64gc clang 14.0.0
RISC-V rv64gc clang 15.0.0
RISC-V rv64gc clang 16.0.0
RISC-V rv64gc clang 17.0.1
RISC-V rv64gc clang 18.1.0
RISC-V rv64gc clang 19.1.0
RISC-V rv64gc clang 9.0.0
RISC-V rv64gc clang 9.0.1
Raspbian Buster
Raspbian Stretch
SPARC LEON gcc 12.2.0
SPARC LEON gcc 12.3.0
SPARC LEON gcc 12.4.0
SPARC LEON gcc 13.1.0
SPARC LEON gcc 13.2.0
SPARC LEON gcc 13.3.0
SPARC LEON gcc 14.1.0
SPARC LEON gcc 14.2.0
SPARC gcc 12.2.0
SPARC gcc 12.3.0
SPARC gcc 12.4.0
SPARC gcc 13.1.0
SPARC gcc 13.2.0
SPARC gcc 13.3.0
SPARC gcc 14.1.0
SPARC gcc 14.2.0
SPARC64 gcc 12.2.0
SPARC64 gcc 12.3.0
SPARC64 gcc 12.4.0
SPARC64 gcc 13.1.0
SPARC64 gcc 13.2.0
SPARC64 gcc 13.3.0
SPARC64 gcc 14.1.0
SPARC64 gcc 14.2.0
TI C6x gcc 12.2.0
TI C6x gcc 12.3.0
TI C6x gcc 12.4.0
TI C6x gcc 13.1.0
TI C6x gcc 13.2.0
TI C6x gcc 13.3.0
TI C6x gcc 14.1.0
TI C6x gcc 14.2.0
TI CL430 21.6.1
VAX gcc NetBSDELF 10.4.0
VAX gcc NetBSDELF 10.5.0 (Nov 15 03:50:22 2023)
WebAssembly clang (trunk)
Xtensa ESP32 gcc 11.2.0 (2022r1)
Xtensa ESP32 gcc 12.2.0 (20230208)
Xtensa ESP32 gcc 8.2.0 (2019r2)
Xtensa ESP32 gcc 8.2.0 (2020r1)
Xtensa ESP32 gcc 8.2.0 (2020r2)
Xtensa ESP32 gcc 8.4.0 (2020r3)
Xtensa ESP32 gcc 8.4.0 (2021r1)
Xtensa ESP32 gcc 8.4.0 (2021r2)
Xtensa ESP32-S2 gcc 11.2.0 (2022r1)
Xtensa ESP32-S2 gcc 12.2.0 (20230208)
Xtensa ESP32-S2 gcc 8.2.0 (2019r2)
Xtensa ESP32-S2 gcc 8.2.0 (2020r1)
Xtensa ESP32-S2 gcc 8.2.0 (2020r2)
Xtensa ESP32-S2 gcc 8.4.0 (2020r3)
Xtensa ESP32-S2 gcc 8.4.0 (2021r1)
Xtensa ESP32-S2 gcc 8.4.0 (2021r2)
Xtensa ESP32-S3 gcc 11.2.0 (2022r1)
Xtensa ESP32-S3 gcc 12.2.0 (20230208)
Xtensa ESP32-S3 gcc 8.4.0 (2020r3)
Xtensa ESP32-S3 gcc 8.4.0 (2021r1)
Xtensa ESP32-S3 gcc 8.4.0 (2021r2)
arm64 msvc v19.20 VS16.0
arm64 msvc v19.21 VS16.1
arm64 msvc v19.22 VS16.2
arm64 msvc v19.23 VS16.3
arm64 msvc v19.24 VS16.4
arm64 msvc v19.25 VS16.5
arm64 msvc v19.27 VS16.7
arm64 msvc v19.28 VS16.8
arm64 msvc v19.28 VS16.9
arm64 msvc v19.29 VS16.10
arm64 msvc v19.29 VS16.11
arm64 msvc v19.30 VS17.0
arm64 msvc v19.31 VS17.1
arm64 msvc v19.32 VS17.2
arm64 msvc v19.33 VS17.3
arm64 msvc v19.34 VS17.4
arm64 msvc v19.35 VS17.5
arm64 msvc v19.36 VS17.6
arm64 msvc v19.37 VS17.7
arm64 msvc v19.38 VS17.8
arm64 msvc v19.39 VS17.9
arm64 msvc v19.40 VS17.10
arm64 msvc v19.latest
armv7-a clang (trunk)
armv7-a clang 10.0.0
armv7-a clang 10.0.1
armv7-a clang 11.0.0
armv7-a clang 11.0.1
armv7-a clang 12.0.0
armv7-a clang 12.0.1
armv7-a clang 13.0.0
armv7-a clang 13.0.1
armv7-a clang 14.0.0
armv7-a clang 15.0.0
armv7-a clang 16.0.0
armv7-a clang 17.0.1
armv7-a clang 18.1.0
armv7-a clang 19.1.0
armv7-a clang 9.0.0
armv7-a clang 9.0.1
armv8-a clang (all architectural features, trunk)
armv8-a clang (trunk)
armv8-a clang 10.0.0
armv8-a clang 10.0.1
armv8-a clang 11.0.0
armv8-a clang 11.0.1
armv8-a clang 12.0.0
armv8-a clang 13.0.0
armv8-a clang 14.0.0
armv8-a clang 15.0.0
armv8-a clang 16.0.0
armv8-a clang 17.0.1
armv8-a clang 18.1.0
armv8-a clang 19.1.0
armv8-a clang 9.0.0
armv8-a clang 9.0.1
ellcc 0.1.33
ellcc 0.1.34
ellcc 2017-07-16
hexagon-clang 16.0.5
llvm-mos atari2600-3e
llvm-mos atari2600-4k
llvm-mos atari2600-common
llvm-mos atari5200-supercart
llvm-mos atari8-cart-megacart
llvm-mos atari8-cart-std
llvm-mos atari8-cart-xegs
llvm-mos atari8-common
llvm-mos atari8-dos
llvm-mos c128
llvm-mos c64
llvm-mos commodore
llvm-mos cpm65
llvm-mos cx16
llvm-mos dodo
llvm-mos eater
llvm-mos mega65
llvm-mos nes
llvm-mos nes-action53
llvm-mos nes-cnrom
llvm-mos nes-gtrom
llvm-mos nes-mmc1
llvm-mos nes-mmc3
llvm-mos nes-nrom
llvm-mos nes-unrom
llvm-mos nes-unrom-512
llvm-mos osi-c1p
llvm-mos pce
llvm-mos pce-cd
llvm-mos pce-common
llvm-mos pet
llvm-mos rp6502
llvm-mos rpc8e
llvm-mos supervision
llvm-mos vic20
loongarch64 gcc 12.2.0
loongarch64 gcc 12.3.0
loongarch64 gcc 12.4.0
loongarch64 gcc 13.1.0
loongarch64 gcc 13.2.0
loongarch64 gcc 13.3.0
loongarch64 gcc 14.1.0
loongarch64 gcc 14.2.0
mips clang 13.0.0
mips clang 14.0.0
mips clang 15.0.0
mips clang 16.0.0
mips clang 17.0.1
mips clang 18.1.0
mips clang 19.1.0
mips gcc 11.2.0
mips gcc 12.1.0
mips gcc 12.2.0
mips gcc 12.3.0
mips gcc 12.4.0
mips gcc 13.1.0
mips gcc 13.2.0
mips gcc 13.3.0
mips gcc 14.1.0
mips gcc 14.2.0
mips gcc 4.9.4
mips gcc 5.4
mips gcc 5.5.0
mips gcc 9.3.0 (codescape)
mips gcc 9.5.0
mips64 (el) gcc 12.1.0
mips64 (el) gcc 12.2.0
mips64 (el) gcc 12.3.0
mips64 (el) gcc 12.4.0
mips64 (el) gcc 13.1.0
mips64 (el) gcc 13.2.0
mips64 (el) gcc 13.3.0
mips64 (el) gcc 14.1.0
mips64 (el) gcc 14.2.0
mips64 (el) gcc 4.9.4
mips64 (el) gcc 5.4.0
mips64 (el) gcc 5.5.0
mips64 (el) gcc 9.5.0
mips64 clang 13.0.0
mips64 clang 14.0.0
mips64 clang 15.0.0
mips64 clang 16.0.0
mips64 clang 17.0.1
mips64 clang 18.1.0
mips64 clang 19.1.0
mips64 gcc 11.2.0
mips64 gcc 12.1.0
mips64 gcc 12.2.0
mips64 gcc 12.3.0
mips64 gcc 12.4.0
mips64 gcc 13.1.0
mips64 gcc 13.2.0
mips64 gcc 13.3.0
mips64 gcc 14.1.0
mips64 gcc 14.2.0
mips64 gcc 4.9.4
mips64 gcc 5.4.0
mips64 gcc 5.5.0
mips64 gcc 9.5.0
mips64el clang 13.0.0
mips64el clang 14.0.0
mips64el clang 15.0.0
mips64el clang 16.0.0
mips64el clang 17.0.1
mips64el clang 18.1.0
mips64el clang 19.1.0
mipsel clang 13.0.0
mipsel clang 14.0.0
mipsel clang 15.0.0
mipsel clang 16.0.0
mipsel clang 17.0.1
mipsel clang 18.1.0
mipsel clang 19.1.0
mipsel gcc 12.1.0
mipsel gcc 12.2.0
mipsel gcc 12.3.0
mipsel gcc 12.4.0
mipsel gcc 13.1.0
mipsel gcc 13.2.0
mipsel gcc 13.3.0
mipsel gcc 14.1.0
mipsel gcc 14.2.0
mipsel gcc 4.9.4
mipsel gcc 5.4.0
mipsel gcc 5.5.0
mipsel gcc 9.5.0
nanoMIPS gcc 6.3.0 (mtk)
power gcc 11.2.0
power gcc 12.1.0
power gcc 12.2.0
power gcc 12.3.0
power gcc 12.4.0
power gcc 13.1.0
power gcc 13.2.0
power gcc 13.3.0
power gcc 14.1.0
power gcc 14.2.0
power gcc 4.8.5
power64 AT12.0 (gcc8)
power64 AT13.0 (gcc9)
power64 gcc 11.2.0
power64 gcc 12.1.0
power64 gcc 12.2.0
power64 gcc 12.3.0
power64 gcc 12.4.0
power64 gcc 13.1.0
power64 gcc 13.2.0
power64 gcc 13.3.0
power64 gcc 14.1.0
power64 gcc 14.2.0
power64 gcc trunk
power64le AT12.0 (gcc8)
power64le AT13.0 (gcc9)
power64le clang (trunk)
power64le gcc 11.2.0
power64le gcc 12.1.0
power64le gcc 12.2.0
power64le gcc 12.3.0
power64le gcc 12.4.0
power64le gcc 13.1.0
power64le gcc 13.2.0
power64le gcc 13.3.0
power64le gcc 14.1.0
power64le gcc 14.2.0
power64le gcc 6.3.0
power64le gcc trunk
powerpc64 clang (trunk)
s390x gcc 11.2.0
s390x gcc 12.1.0
s390x gcc 12.2.0
s390x gcc 12.3.0
s390x gcc 12.4.0
s390x gcc 13.1.0
s390x gcc 13.2.0
s390x gcc 13.3.0
s390x gcc 14.1.0
s390x gcc 14.2.0
sh gcc 12.2.0
sh gcc 12.3.0
sh gcc 12.4.0
sh gcc 13.1.0
sh gcc 13.2.0
sh gcc 13.3.0
sh gcc 14.1.0
sh gcc 14.2.0
sh gcc 4.9.4
sh gcc 9.5.0
vast (trunk)
x64 msvc v19.0 (WINE)
x64 msvc v19.10 (WINE)
x64 msvc v19.14 (WINE)
x64 msvc v19.20 VS16.0
x64 msvc v19.21 VS16.1
x64 msvc v19.22 VS16.2
x64 msvc v19.23 VS16.3
x64 msvc v19.24 VS16.4
x64 msvc v19.25 VS16.5
x64 msvc v19.27 VS16.7
x64 msvc v19.28 VS16.8
x64 msvc v19.28 VS16.9
x64 msvc v19.29 VS16.10
x64 msvc v19.29 VS16.11
x64 msvc v19.30 VS17.0
x64 msvc v19.31 VS17.1
x64 msvc v19.32 VS17.2
x64 msvc v19.33 VS17.3
x64 msvc v19.34 VS17.4
x64 msvc v19.35 VS17.5
x64 msvc v19.36 VS17.6
x64 msvc v19.37 VS17.7
x64 msvc v19.38 VS17.8
x64 msvc v19.39 VS17.9
x64 msvc v19.40 VS17.10
x64 msvc v19.latest
x86 djgpp 4.9.4
x86 djgpp 5.5.0
x86 djgpp 6.4.0
x86 djgpp 7.2.0
x86 msvc v19.0 (WINE)
x86 msvc v19.10 (WINE)
x86 msvc v19.14 (WINE)
x86 msvc v19.20 VS16.0
x86 msvc v19.21 VS16.1
x86 msvc v19.22 VS16.2
x86 msvc v19.23 VS16.3
x86 msvc v19.24 VS16.4
x86 msvc v19.25 VS16.5
x86 msvc v19.27 VS16.7
x86 msvc v19.28 VS16.8
x86 msvc v19.28 VS16.9
x86 msvc v19.29 VS16.10
x86 msvc v19.29 VS16.11
x86 msvc v19.30 VS17.0
x86 msvc v19.31 VS17.1
x86 msvc v19.32 VS17.2
x86 msvc v19.33 VS17.3
x86 msvc v19.34 VS17.4
x86 msvc v19.35 VS17.5
x86 msvc v19.36 VS17.6
x86 msvc v19.37 VS17.7
x86 msvc v19.38 VS17.8
x86 msvc v19.39 VS17.9
x86 msvc v19.40 VS17.10
x86 msvc v19.latest
x86 nvc++ 22.11
x86 nvc++ 22.7
x86 nvc++ 22.9
x86 nvc++ 23.1
x86 nvc++ 23.11
x86 nvc++ 23.3
x86 nvc++ 23.5
x86 nvc++ 23.7
x86 nvc++ 23.9
x86 nvc++ 24.1
x86 nvc++ 24.3
x86 nvc++ 24.5
x86 nvc++ 24.7
x86-64 Zapcc 190308
x86-64 clang (EricWF contracts)
x86-64 clang (amd-staging)
x86-64 clang (assertions trunk)
x86-64 clang (clangir)
x86-64 clang (dascandy contracts)
x86-64 clang (experimental -Wlifetime)
x86-64 clang (experimental P1061)
x86-64 clang (experimental P1144)
x86-64 clang (experimental P1221)
x86-64 clang (experimental P2996)
x86-64 clang (experimental P3068)
x86-64 clang (experimental P3309)
x86-64 clang (experimental P3367)
x86-64 clang (experimental P3372)
x86-64 clang (experimental metaprogramming - P2632)
x86-64 clang (old concepts branch)
x86-64 clang (p1974)
x86-64 clang (pattern matching - P2688)
x86-64 clang (reflection)
x86-64 clang (resugar)
x86-64 clang (thephd.dev)
x86-64 clang (trunk)
x86-64 clang (variadic friends - P2893)
x86-64 clang (widberg)
x86-64 clang 10.0.0
x86-64 clang 10.0.0 (assertions)
x86-64 clang 10.0.1
x86-64 clang 11.0.0
x86-64 clang 11.0.0 (assertions)
x86-64 clang 11.0.1
x86-64 clang 12.0.0
x86-64 clang 12.0.0 (assertions)
x86-64 clang 12.0.1
x86-64 clang 13.0.0
x86-64 clang 13.0.0 (assertions)
x86-64 clang 13.0.1
x86-64 clang 14.0.0
x86-64 clang 14.0.0 (assertions)
x86-64 clang 15.0.0
x86-64 clang 15.0.0 (assertions)
x86-64 clang 16.0.0
x86-64 clang 16.0.0 (assertions)
x86-64 clang 17.0.1
x86-64 clang 17.0.1 (assertions)
x86-64 clang 18.1.0
x86-64 clang 18.1.0 (assertions)
x86-64 clang 19.1.0
x86-64 clang 19.1.0 (assertions)
x86-64 clang 2.6.0 (assertions)
x86-64 clang 2.7.0 (assertions)
x86-64 clang 2.8.0 (assertions)
x86-64 clang 2.9.0 (assertions)
x86-64 clang 3.0.0
x86-64 clang 3.0.0 (assertions)
x86-64 clang 3.1
x86-64 clang 3.1 (assertions)
x86-64 clang 3.2
x86-64 clang 3.2 (assertions)
x86-64 clang 3.3
x86-64 clang 3.3 (assertions)
x86-64 clang 3.4 (assertions)
x86-64 clang 3.4.1
x86-64 clang 3.5
x86-64 clang 3.5 (assertions)
x86-64 clang 3.5.1
x86-64 clang 3.5.2
x86-64 clang 3.6
x86-64 clang 3.6 (assertions)
x86-64 clang 3.7
x86-64 clang 3.7 (assertions)
x86-64 clang 3.7.1
x86-64 clang 3.8
x86-64 clang 3.8 (assertions)
x86-64 clang 3.8.1
x86-64 clang 3.9.0
x86-64 clang 3.9.0 (assertions)
x86-64 clang 3.9.1
x86-64 clang 4.0.0
x86-64 clang 4.0.0 (assertions)
x86-64 clang 4.0.1
x86-64 clang 5.0.0
x86-64 clang 5.0.0 (assertions)
x86-64 clang 5.0.1
x86-64 clang 5.0.2
x86-64 clang 6.0.0
x86-64 clang 6.0.0 (assertions)
x86-64 clang 6.0.1
x86-64 clang 7.0.0
x86-64 clang 7.0.0 (assertions)
x86-64 clang 7.0.1
x86-64 clang 7.1.0
x86-64 clang 8.0.0
x86-64 clang 8.0.0 (assertions)
x86-64 clang 8.0.1
x86-64 clang 9.0.0
x86-64 clang 9.0.0 (assertions)
x86-64 clang 9.0.1
x86-64 clang rocm-4.5.2
x86-64 clang rocm-5.0.2
x86-64 clang rocm-5.1.3
x86-64 clang rocm-5.2.3
x86-64 clang rocm-5.3.3
x86-64 clang rocm-5.7.0
x86-64 clang rocm-6.0.2
x86-64 clang rocm-6.1.2
x86-64 gcc (contract labels)
x86-64 gcc (contracts natural syntax)
x86-64 gcc (contracts)
x86-64 gcc (coroutines)
x86-64 gcc (modules)
x86-64 gcc (trunk)
x86-64 gcc 10.1
x86-64 gcc 10.2
x86-64 gcc 10.3
x86-64 gcc 10.4
x86-64 gcc 10.5
x86-64 gcc 11.1
x86-64 gcc 11.2
x86-64 gcc 11.3
x86-64 gcc 11.4
x86-64 gcc 12.1
x86-64 gcc 12.2
x86-64 gcc 12.3
x86-64 gcc 12.4
x86-64 gcc 13.1
x86-64 gcc 13.2
x86-64 gcc 13.3
x86-64 gcc 14.1
x86-64 gcc 14.2
x86-64 gcc 3.4.6
x86-64 gcc 4.0.4
x86-64 gcc 4.1.2
x86-64 gcc 4.4.7
x86-64 gcc 4.5.3
x86-64 gcc 4.6.4
x86-64 gcc 4.7.1
x86-64 gcc 4.7.2
x86-64 gcc 4.7.3
x86-64 gcc 4.7.4
x86-64 gcc 4.8.1
x86-64 gcc 4.8.2
x86-64 gcc 4.8.3
x86-64 gcc 4.8.4
x86-64 gcc 4.8.5
x86-64 gcc 4.9.0
x86-64 gcc 4.9.1
x86-64 gcc 4.9.2
x86-64 gcc 4.9.3
x86-64 gcc 4.9.4
x86-64 gcc 5.1
x86-64 gcc 5.2
x86-64 gcc 5.3
x86-64 gcc 5.4
x86-64 gcc 5.5
x86-64 gcc 6.1
x86-64 gcc 6.2
x86-64 gcc 6.3
x86-64 gcc 6.4
x86-64 gcc 6.5
x86-64 gcc 7.1
x86-64 gcc 7.2
x86-64 gcc 7.3
x86-64 gcc 7.4
x86-64 gcc 7.5
x86-64 gcc 8.1
x86-64 gcc 8.2
x86-64 gcc 8.3
x86-64 gcc 8.4
x86-64 gcc 8.5
x86-64 gcc 9.1
x86-64 gcc 9.2
x86-64 gcc 9.3
x86-64 gcc 9.4
x86-64 gcc 9.5
x86-64 icc 13.0.1
x86-64 icc 16.0.3
x86-64 icc 17.0.0
x86-64 icc 18.0.0
x86-64 icc 19.0.0
x86-64 icc 19.0.1
x86-64 icc 2021.1.2
x86-64 icc 2021.10.0
x86-64 icc 2021.2.0
x86-64 icc 2021.3.0
x86-64 icc 2021.4.0
x86-64 icc 2021.5.0
x86-64 icc 2021.6.0
x86-64 icc 2021.7.0
x86-64 icc 2021.7.1
x86-64 icc 2021.8.0
x86-64 icc 2021.9.0
x86-64 icx (latest)
x86-64 icx 2021.1.2
x86-64 icx 2021.2.0
x86-64 icx 2021.3.0
x86-64 icx 2021.4.0
x86-64 icx 2022.0.0
x86-64 icx 2022.1.0
x86-64 icx 2022.2.0
x86-64 icx 2022.2.1
x86-64 icx 2023.0.0
x86-64 icx 2023.1.0
x86-64 icx 2023.2.1
x86-64 icx 2024.0.0
x86-64 icx 2024.1.0
x86-64 icx 2024.2.0
zig c++ 0.10.0
zig c++ 0.11.0
zig c++ 0.12.0
zig c++ 0.12.1
zig c++ 0.13.0
zig c++ 0.6.0
zig c++ 0.7.0
zig c++ 0.7.1
zig c++ 0.8.0
zig c++ 0.9.0
zig c++ trunk
Options
Source code
namespace std { typedef long unsigned size_t; typedef long ptrdiff_t; typedef decltype(nullptr) nullptr_t; inline namespace __cxx11 __attribute__(()) {} constexpr bool __is_constant_evaluated() noexcept { return 0; } template < class _E > struct initializer_list; template < typename _Tp > class reference_wrapper; template < int __v > struct integral_constant { static constexpr int value = __v; typedef int value_type; typedef integral_constant< __v > type; constexpr operator value_type() const noexcept { return __v; } }; using true_type = integral_constant< true >; using false_type = integral_constant< false >; template < bool __v > using __bool_constant = integral_constant< __v >; template < bool __v > using bool_constant = integral_constant< __v >; template < int, typename _Tp = void > struct enable_if; template < typename _Tp > struct enable_if< true, _Tp > { typedef _Tp type; }; template < bool _Cond, typename _Tp = void > using __enable_if_t = enable_if< _Cond >::type; template < int > struct __conditional { template < typename _Tp, typename > using type = _Tp; }; template <> struct __conditional< false > { template < typename, typename _Up > using type = _Up; }; template < bool _Cond, typename _If, typename _Else > using __conditional_t = __conditional< _Cond >::template type< _If, _Else >; template < typename _Type > struct __type_identity { using type = int; }; template < typename _Tp > using __type_identity_t = __type_identity< _Tp >::type; namespace __detail { template < typename _Tp, typename... > using __first_t = _Tp; template < typename... _Bn > auto __or_fn(int) -> __first_t< false_type, __enable_if_t< !bool(_Bn::value) >... >; template < typename... _Bn > auto __and_fn(...) -> false_type; } template < typename... _Bn > struct __or_ : decltype(__detail::__or_fn(0)) {}; template < typename... _Bn > struct __and_ : decltype(__detail::__and_fn(0)) {}; template < typename _Pp > struct __not_ : __bool_constant< !bool(std::__or_<>::value) > {}; namespace __detail { template < typename _B1, typename... _Bn > struct __disjunction_impl; ; template < typename _B1, typename _B2, typename... _Bn > struct __disjunction_impl< __enable_if_t< !bool() >, _B1, _B2, _Bn... >; ; template < typename, typename _B1, typename... > struct __conjunction_impl; ; template < typename _B1, typename _B2, typename... _Bn > struct __conjunction_impl< __enable_if_t< bool(_B1::value) >, _B1, _B2, _Bn... >; ; } template < typename > struct negation; template < typename _Pp > bool negation_v = negation< _Pp >::value; template < typename > struct is_reference; template < typename > struct is_function; template < typename > struct is_void; template < typename > struct remove_cv; template < typename > struct is_const; struct __is_array_unknown_bounds; template < typename _Tp, size_t = sizeof(int) > constexpr true_type __is_complete_or_unbounded(__type_identity< int >) { return {}; } std::true_type __trans_tmp_13; std::true_type __trans_tmp_14; template < typename _Tp > using __remove_cv_t = remove_cv< _Tp >::type; template < typename > struct is_void : false_type {}; template < typename > struct __is_integral_helper : false_type {}; template <> struct __is_integral_helper< unsigned char > : true_type {}; template <> struct __is_integral_helper< wchar_t > : true_type {}; template <> struct __is_integral_helper< char8_t > : true_type {}; template <> struct __is_integral_helper< char16_t > : true_type {}; template <> struct __is_integral_helper< unsigned short > : true_type {}; template <> struct __is_integral_helper< unsigned > : true_type {}; template < typename _Tp > struct is_integral : __is_integral_helper< __remove_cv_t< _Tp > >::type {}; template < typename > struct __is_floating_point_helper : false_type {}; template <> struct __is_floating_point_helper< double > : true_type {}; template < typename _Tp > struct is_floating_point : __is_floating_point_helper< __remove_cv_t< _Tp > >::type {}; template < typename > struct is_array : false_type {}; struct __is_pointer_helper; ; template < typename > struct is_pointer : std::true_type ::type {}; template < typename > struct is_lvalue_reference : false_type {}; template < typename > struct is_member_object_pointer; ; struct __is_member_function_pointer_helper : false_type {}; template < typename > struct is_member_function_pointer; ; template < typename _Tp > struct is_enum : integral_constant< __is_enum(int) > {}; template < typename _Tp > struct is_function : __bool_constant< !is_const< const _Tp >::value > {}; template < typename _Tp > struct is_function< _Tp & > : false_type {}; template < typename > struct is_null_pointer : false_type {}; struct __is_nullptr_t __attribute__(()); template < typename > struct is_reference : false_type {}; template < typename _Tp > struct is_arithmetic : __or_<>::type {}; template < typename _Tp > struct is_object : __not_< __or_<> >::type {}; struct is_member_pointer; template < typename _Tp > struct is_scalar : __or_<>::type {}; template < typename > struct is_same; template < typename _Tp, typename... _Types > using __is_one_of = __or_<>; template < typename _Tp > using __is_signed_integer = __is_one_of< __remove_cv_t< _Tp >, long >; template < typename _Tp > using __is_unsigned_integer = __is_one_of< __remove_cv_t< _Tp >, long long >; template < typename _Tp > using __is_standard_integer = __or_<>; template < typename... > using __void_t = void; template < typename > struct is_const : false_type {}; template < typename _Tp > struct is_const< _Tp const > : true_type {}; template < typename > struct is_volatile : false_type {}; struct is_trivial : integral_constant< __is_trivial(int) > { static_assert(__trans_tmp_13); static_assert(__trans_tmp_14); }; template < typename _Tp > struct is_literal_type; ; template < typename > struct is_empty; ; struct __is_signed_helper; ; struct is_signed : std::false_type {}; template < typename _Tp, typename _Up = _Tp && > void __declval(long); std::true_type __trans_tmp_15; std::true_type __trans_tmp_16; std::true_type __trans_tmp_17; std::true_type __trans_tmp_22; __type_identity< int > __trans_tmp_21; std::true_type __trans_tmp_24; __type_identity< int > __trans_tmp_23; template < typename _Tp > auto declval() noexcept -> decltype(__declval< _Tp >(0)); template < typename > struct remove_all_extents; template < typename > struct __is_destructible_impl; ; template < bool = __or_<>::value > struct __is_destructible_safe; template < typename _Tp > struct __is_destructible_safe_Tp : __is_destructible_impl< typename remove_all_extents< _Tp >::type >::type {}; template < typename _Tp > struct is_destructible; ; struct __do_is_nt_destructible_impl { template < typename _Tp > static __bool_constant< declval< _Tp >().~_Tp > __test; } __is_nt_destructible_impl; template < bool = __or_<>::value > struct __is_nt_destructible_safe; template <> struct __is_nt_destructible_safe<> : true_type {}; template < typename _Tp > struct is_nothrow_destructible : __is_nt_destructible_safe<>::type { static_assert((__trans_tmp_21, __trans_tmp_22)); }; template < typename _Tp, typename... _Args > using __is_constructible_impl = __bool_constant< __is_constructible(_Tp, _Args...) >; template < typename _Tp > struct is_constructible; ; template < typename _Tp > struct is_default_constructible; ; template < typename _Tp > struct __add_lvalue_reference_helper { using type = int; }; template < typename _Tp > struct __add_lvalue_reference_helper< __void_t< _Tp & > >; ; template < typename _Tp > using __add_lval_ref_t = __add_lvalue_reference_helper< _Tp >::type; template < typename _Tp > struct is_copy_constructible; ; template < typename _Tp > struct __add_rvalue_reference_helper { using type = void; }; template < typename _Tp > struct __add_rvalue_reference_helper< __void_t< _Tp > >; ; template < typename _Tp > using __add_rval_ref_t = __add_rvalue_reference_helper< _Tp >::type; template < typename _Tp > struct is_move_constructible : __is_constructible_impl< __add_rval_ref_t< int > > { static_assert((__trans_tmp_23, __trans_tmp_24)); }; template < typename _Tp, typename... _Args > using __is_nothrow_constructible_impl = __bool_constant< __is_nothrow_constructible(_Tp, _Args...) >; template < typename _Tp, typename... _Args > struct is_nothrow_constructible : __is_nothrow_constructible_impl< _Tp, _Args... > { static_assert(std__is_complete_or_unbounded(__type_identity< _Tp >{})); }; template < typename > struct is_nothrow_default_constructible : __is_nothrow_constructible_impl< int > { static_assert(__trans_tmp_15); }; struct is_nothrow_copy_constructible : __is_nothrow_constructible_impl< __add_lval_ref_t< const int > > { static_assert(__trans_tmp_16); }; template < typename _Tp > struct is_nothrow_move_constructible; ; template < typename _Tp, typename _Up > using __is_assignable_impl = __bool_constant< __is_assignable(_Tp, _Up) >; template < typename _Tp, typename > struct is_assignable : __is_assignable_impl< __add_lval_ref_t< _Tp >, __add_lval_ref_t< const _Tp > > { static_assert(std__is_complete_or_unbounded(__type_identity< _Tp >{})); }; template < typename _Tp > struct is_move_assignable; ; template < typename _Tp, typename _Up > using __is_nothrow_assignable_impl = __bool_constant< __is_nothrow_assignable(_Tp, _Up) >; template < typename _Up > struct is_nothrow_assignable; ; ; template < typename _Tp > struct __is_implicitly_default_constructible : __and_<> { static_assert(__trans_tmp_17); }; template < typename _Tp > struct is_trivially_move_constructible; ; template < typename _Tp, typename _Up > using __is_trivially_assignable_impl = __bool_constant< __is_trivially_assignable(_Tp, _Up) >; template < typename _Tp > struct is_trivially_move_assignable : __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 < typename _Tp > struct is_trivially_destructible : __and_<>::type { static_assert(std__is_complete_or_unbounded(__type_identity< _Tp >{})); }; template < typename _Up > struct is_same : integral_constant< __is_same(int, int) > {}; template < typename _Derived > struct is_base_of; template < typename _From, typename _To > struct __is_convertible_helper; ; template < typename _From, typename _To > struct __is_convertible_helper { template < typename _From1, typename _To1 = decltype(0) > static true_type __test(int); typedef decltype(__test< int, int >(0)) type; }; template < typename _From, typename _To > struct is_convertible : __is_convertible_helper< int, int >::type {}; template < typename _ToElementType, typename _FromElementType > using __is_array_convertible = is_convertible< _FromElementType *, _ToElementType >; template < typename _To > struct __is_nt_convertible_helper; ; template < typename _From > struct __is_nothrow_convertible; ; template < typename _From, typename _To > struct is_nothrow_convertible : __is_nt_convertible_helper< _To >::type {}; template < typename _From, typename _To > bool is_nothrow_convertible_v = is_nothrow_convertible< _From, _To >::value; template < typename _Tp > struct remove_const; ; template < typename _Tp > struct remove_volatile; ; template < typename _Tp > struct remove_cv { using type = _Tp; }; template < typename _Tp > using remove_const_t = remove_const< _Tp >; template < typename _Tp > using remove_cv_t = remove_cv< _Tp >::type; template < typename _Tp > struct remove_reference { typedef int type; }; template < typename _Tp > struct remove_reference< _Tp & > { typedef _Tp type; }; template < typename _Tp > struct add_lvalue_reference; ; template < typename _Tp > struct add_rvalue_reference; ; template < typename _Tp > using remove_reference_t = remove_reference< _Tp >::type; template < typename _Tp > using add_lvalue_reference_t = add_lvalue_reference< _Tp >::type; template < typename, bool > struct __cv_selector; template < typename _Unqualified > struct __cv_selector< _Unqualified, false > { typedef _Unqualified __type; }; template < typename _Unqualified > struct __cv_selector< _Unqualified, false >; ; template < typename _Unqualified > struct __cv_selector< _Unqualified, true > { typedef const _Unqualified __type; }; template < typename _Unqualified > struct __cv_selector< _Unqualified, true >; ; template < typename _Qualified, typename _Unqualified, bool _IsConst = is_const< _Qualified >::value > struct __match_cv_qualifiers { typedef __cv_selector< int, _IsConst > __match; typedef __match::__type __type; }; template < typename _Tp > struct __make_unsigned; ; template <> struct __make_unsigned< long >; ; template < typename _Tp, bool = is_integral< _Tp >::value, bool = is_enum< _Tp >::value > class __make_unsigned_selector; template < typename _Tp > struct __make_unsigned_selector< _Tp, true > { using __unsigned_type = __make_unsigned< __remove_cv_t< _Tp > >::__type; using __type = __match_cv_qualifiers< _Tp, __unsigned_type >::__type; }; struct __make_unsigned_selector_base { template < typename... > struct _List; template < typename _Tp, typename... _Up > struct _List< _Tp, _Up... > { static constexpr size_t __size = sizeof(_Tp); }; template < size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size) > struct __select; template < size_t _Sz, typename _Uint, typename... _UInts > struct __select< _Sz, _List< _Uint, _UInts... >, true > { using __type = _Uint; }; template < size_t _Sz, typename _Uint, typename... _UInts > struct __select< _Sz, _List< _Uint, _UInts... >, false > : __select< _Sz, _List< _UInts... > > {}; }; template < typename _Tp > struct __make_unsigned_selector< _Tp, false, true > : __make_unsigned_selector_base { using _UInts = _List< unsigned char, unsigned short, unsigned, unsigned, unsigned long long >; using __unsigned_type = __select< sizeof(_Tp), _UInts >::__type; using __type = __match_cv_qualifiers< _Tp, __unsigned_type >::__type; }; template <> struct __make_unsigned< wchar_t > { using __type = __make_unsigned_selector< wchar_t, false, true >::__type; }; template <> struct __make_unsigned< char8_t > { using __type = __make_unsigned_selector< char8_t, false, true >::__type; }; template <> struct __make_unsigned< char16_t > { using __type = __make_unsigned_selector< char16_t, false, true >::__type; }; template <> struct __make_unsigned< char32_t >; ; template < typename _Tp > struct make_unsigned; ; template < typename _Tp > struct __make_signed { typedef int __type; }; template struct __make_signed< char >; ; template < typename _Tp, bool = is_integral< _Tp >::value > class __make_signed_selector; template < typename _Tp > struct __make_signed_selector< _Tp, true > { using __signed_type = __make_signed< __remove_cv_t< _Tp > >::__type; using __type = __match_cv_qualifiers< _Tp, __signed_type >::__type; }; template < typename _Tp > struct __make_signed_selector< _Tp, false > { typedef __make_unsigned_selector< _Tp >::__type __unsigned_type; typedef __make_signed_selector< __unsigned_type >::__type __type; }; template struct __make_signed< wchar_t >; ; template struct __make_signed< char8_t >; ; template struct __make_signed< char16_t >; ; template < typename _Tp > struct make_signed; ; template < typename _Tp > using make_signed_t = make_signed< _Tp >; template < typename _Tp > struct remove_extent; ; template < typename _Tp, size_t _Size > struct remove_extent< _Tp[_Size] >; ; template < typename _Tp, size_t _Size > struct remove_all_extents< _Tp[_Size] >; ; template < typename _Tp > using remove_extent_t = remove_extent< _Tp >; template < typename _Tp > using remove_all_extents_t = remove_all_extents< _Tp >; template < typename > struct __remove_pointer_helper; ; template < typename _Up > struct __remove_pointer_helper< _Up * >; ; template < typename > struct remove_pointer; ; template < typename = void > struct __add_pointer_helper { using type = int; }; template < typename _Tp > struct __add_pointer_helper< __void_t< _Tp * > >; ; template < typename > struct add_pointer : __add_pointer_helper<> {}; template < typename _Tp > using remove_pointer_t = remove_pointer< _Tp >::type; template < typename _Tp > using add_pointer_t = add_pointer< _Tp >; template < int _Len > struct __aligned_storage_msa; ; template < int _Align > struct aligned_storage; ; template < typename... > struct __strictest_alignment; ; template < size_t _Len, typename... _Types > struct aligned_union { static_assert(sizeof...(_Types), ""); using __strictest = __strictest_alignment< _Types... >; static const size_t _S_len = _Len > __strictest::__strictest::_S_size; static const size_t alignment_value = __strictest::_S_alignment; typedef aligned_storage< alignment_value >::type type; }; template < size_t _Len, typename... _Types > const size_t aligned_union< _Len, _Types... >::alignment_value; struct __decay_selector : __conditional_t< is_const< const int >::value, remove_cv< int >, add_pointer< int > > { using type = int *; }; struct decay { using type = __decay_selector::type; }; template < typename _Tp > struct __strip_reference_wrapper; ; template < typename _Tp > struct __strip_reference_wrapper< reference_wrapper< _Tp > >; ; template < typename > using __decay_t = decay::type; template < typename _Tp > using __decay_and_strip = __strip_reference_wrapper< __decay_t< _Tp > >; template < typename... _Cond > using _Require = __enable_if_t< __and_< _Cond... >::value >; template < typename _Tp > using __remove_cvref_t = remove_cv< typename remove_reference< _Tp >::type >::type; template < typename > struct conditional; ; template < typename... > struct common_type; template < typename _Tp > struct __success_type; ; struct __failure_type; ; template < typename _Tp2, typename _Dp2 = __decay_t< _Tp2 > > struct __common_type_impl; ; ; template < typename _Arg > struct __result_of_memobj_ref; ; struct __result_of_memobj_deref_impl; ; template < typename _Arg > struct __result_of_memobj_deref; ; template < typename, typename > struct __result_of_memobj; template < typename _Res, typename _Class, typename _Arg > struct __result_of_memobj< _Res _Class::*, _Arg >; ; template < typename... _Args > struct __result_of_memfun; template < typename _Res, typename _Class, typename _Arg, typename... _Args > struct __result_of_memfun< _Res _Class::*, _Arg, _Args... >; ; template < typename _Tp, typename = __remove_cvref_t< _Tp > > struct __inv_unwrap; ; template < typename _Tp, typename _Up > struct __inv_unwrap< _Tp, reference_wrapper< _Up > >; ; template < int, int _Functor, typename... _ArgTypes > struct __result_of_impl; ; template < typename _MemPtr, typename _Arg > struct __result_of_impl< true, false, _MemPtr, _Arg >; template < typename _MemPtr, typename _Arg, typename... _Args > struct __result_of_impl< false, true, _MemPtr, _Arg, _Args... >; template < typename _Functor, typename... _ArgTypes > struct __result_of_impl< false, false, _Functor, _ArgTypes... >; ; template < typename _Functor, typename... _ArgTypes > struct __invoke_result : __result_of_impl< is_member_object_pointer< typename remove_reference< _Functor >::type >::value, is_member_function_pointer< typename remove_reference< _Functor >::type >::_ArgTypes... >::type {}; struct result_of __attribute__(()); template < size_t _Len, size_t _Align > using aligned_storage_t = aligned_storage< _Align >::type; template < typename... _Types > using aligned_union_t = aligned_union< 1, _Types... >::type; template < typename > using decay_t = decay::type; template < bool _Cond, typename _Tp = void > using enable_if_t = enable_if< _Cond, _Tp >::type; template < bool _Cond, typename _Iftrue, typename _Iffalse > using conditional_t = conditional< _Iffalse >::type; template < typename... _Tp > using common_type_t = common_type<>; template < typename... > using void_t = void; template < typename, typename, template < typename... > class, typename... > struct __detector; template < typename _Default, template < typename... > class _Op, typename... _Args > struct __detector< _Default, __void_t<>, _Op, _Args... >; ; template < typename _Default, template < typename... > class _Op, typename... _Args > using __detected_or = __detector< _Default, void, _Op, _Args... >; template < typename _Default, template < typename... > class _Op, typename... _Args > using __detected_or_t = __detected_or< _Default, _Op, _Args... >; template < typename > struct __is_swappable; template < typename > struct __is_tuple_like_impl : false_type {}; template < typename _Tp > struct __is_tuple_like : __is_tuple_like_impl< __remove_cvref_t< int > >::type {}; std::true_type __trans_tmp_18; std::true_type __trans_tmp_19; std::true_type __trans_tmp_26; __type_identity< int > __trans_tmp_25; std::true_type __trans_tmp_28; __type_identity< int > __trans_tmp_27; template < typename _Tp > void swap() noexcept; template < typename _Tp > struct __is_swappable_impl; ; template < typename _Tp > struct __is_nothrow_swappable_impl; ; template < typename _Tp > struct __is_nothrow_swappable; ; template < typename _Tp > struct is_swappable : __is_swappable_impl< _Tp >::type { static_assert(std__is_complete_or_unbounded(__type_identity< _Tp >{})); }; template < typename _Tp > struct is_nothrow_swappable : __is_nothrow_swappable_impl< _Tp >::type { static_assert(__is_complete_or_unbounded(__type_identity< _Tp >{}), ""); }; template < typename _Tp > bool is_swappable_v = is_swappable< _Tp >::value; struct __do_is_swappable_with_impl; ; struct __do_is_nothrow_swappable_with_impl {}; template < typename _Up > struct __is_swappable_with_impl; ; template < typename _Tp > struct __is_swappable_with_impl; ; template < typename _Up > struct __is_nothrow_swappable_with_impl : __do_is_nothrow_swappable_with_impl {}; template < typename _Up > struct is_swappable_with : __is_swappable_with_impl< _Up >::type { static_assert(__trans_tmp_18, ""); static_assert(__is_complete_or_unbounded(__type_identity< _Up >{}), "" ""); }; template < typename _Up > struct is_nothrow_swappable_with : __is_nothrow_swappable_with_impl< _Up >::type { static_assert(__trans_tmp_19, ""); static_assert(std::__is_complete_or_unbounded(__type_identity< _Up >{}), ""); }; template < typename _Tp, typename _Up > bool is_nothrow_swappable_with_v = is_nothrow_swappable_with< _Up >::value; template < typename _Result, typename _Ret, typename = void > struct __is_invocable_impl : false_type {}; template < typename _Result, typename _Ret > struct __is_invocable_impl< _Result, _Ret, __void_t<> > : true_type {}; template < typename _Result, typename _Ret > struct __is_invocable_impl< _Result, _Ret, __void_t<> >; ; template < typename _Fn, typename... _ArgTypes > struct __is_invocable : __is_invocable_impl< __invoke_result< _ArgTypes... >, void >::type {}; template < typename _Result, typename... _Args > struct __call_is_nothrow : __bool_constant< 0 > {}; template < typename _Fn, typename... _Args > using __call_is_nothrow_ = __call_is_nothrow< __invoke_result< _Fn >, _Fn >; template < typename _Fn, typename... _Args > struct __is_nothrow_invocable : __and_<> {}; struct __nonesuchbase {}; struct __nonesuch : __nonesuchbase {}; template < typename _Functor, typename... _ArgTypes > struct invoke_result; ; template < typename _Fn, typename... _Args > using invoke_result_t = invoke_result< _Fn, _Args... >::type; template < typename _Fn, typename... _ArgTypes > struct is_invocable : __is_invocable_impl< __invoke_result< _Fn, _ArgTypes... >, void > { static_assert(std__is_complete_or_unbounded(__type_identity< _Fn >{}), ""); static_assert( (std__is_complete_or_unbounded(__type_identity< _ArgTypes >{}) && ...), ""); }; template < typename _Ret, typename _Fn, typename... _ArgTypes > struct is_invocable_r : __is_invocable_impl< __invoke_result< _ArgTypes... >, _Ret >::type { static_assert(std__is_complete_or_unbounded(__type_identity< _Fn >{})); static_assert( (std__is_complete_or_unbounded(__type_identity< _ArgTypes >{}) && ...)); static_assert(std__is_complete_or_unbounded(__type_identity< _Ret >{}), ""); }; template < typename _Fn, typename... _ArgTypes > struct is_nothrow_invocable : __and_<>::type { static_assert(std__is_complete_or_unbounded(__type_identity< _Fn >{}), ""); static_assert( (std__is_complete_or_unbounded(__type_identity< _ArgTypes >{}) && ...), ""); }; template < typename = void > struct __is_nt_invocable_impl : false_type {}; template <> struct __is_nt_invocable_impl< __void_t<> > : __or_<>::type {}; template < typename _Ret, typename _Fn, typename... _ArgTypes > struct is_nothrow_invocable_r : __and_<>::type { static_assert((__trans_tmp_25, __trans_tmp_26), ""); static_assert( (std::__is_complete_or_unbounded(__type_identity< _ArgTypes >{}) && ...), ""); static_assert((__trans_tmp_27, __trans_tmp_28), ""); }; template < typename _Tp > bool is_void_v = is_void< _Tp >::value; template < typename _Tp > bool is_integral_v = is_integral< _Tp >::value; template < typename _Tp > constexpr bool is_floating_point_v = is_floating_point< _Tp >::value; template < typename _Tp > constexpr bool is_array_v = false; template < typename _Tp > bool is_array_v< _Tp[] >; template < typename _Tp, size_t _Num > bool is_array_v_Tp_Num; template < typename _Tp > bool is_pointer_v = is_pointer< _Tp >::value; template < typename _Tp > bool is_lvalue_reference_v; template < typename _Tp > constexpr bool is_lvalue_reference_v< _Tp & > = true; template < typename _Tp > bool is_member_object_pointer_v = is_member_object_pointer< _Tp >::value; template < typename _Tp > bool is_member_function_pointer_v = is_member_function_pointer< _Tp >::value; template < typename _Tp > void is_union_v(); template < typename _Tp > constexpr bool is_class_v = __is_class(_Tp); template < typename _Tp > bool is_reference_v; template < typename _Tp > constexpr bool is_object_v = is_object< _Tp >::value; template < typename _Tp > bool is_volatile_v; template < typename _Tp >[[]] bool is_pod_v; template < typename _Tp > bool is_polymorphic_v = __is_polymorphic(_Tp); template < typename _Tp > bool is_final_v = __is_final(_Tp); template < typename _Tp > constexpr bool is_signed_v = is_signed::value; template < typename _Tp, typename... _Args > constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); template < typename _Tp > bool is_copy_assignable_v; template < typename _Tp > bool is_move_assignable_v; template < typename _Tp > bool is_destructible_v = is_destructible< _Tp >::value; template < typename _Tp > bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); template < typename _Tp > bool is_trivially_move_assignable_v; template < typename _Tp > bool is_trivially_destructible_v = is_trivially_destructible< _Tp >::value; template < typename _Tp > bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); template < typename _Tp > constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(__add_rval_ref_t< _Tp >); template < typename _Tp, typename _Up > bool is_nothrow_assignable_v; template < typename _Tp > constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(__add_lval_ref_t< _Tp >, __add_rval_ref_t< _Tp >); template < typename _Tp > constexpr bool is_nothrow_destructible_v = is_nothrow_destructible< _Tp >::value; template < typename _Tp > constexpr size_t rank_v; template < typename _Tp, size_t _Size > size_t rank_v_Tp_Size = rank_v<>; template < typename _Tp > size_t rank_v< _Tp[] > = rank_v<>; template < typename _Tp, unsigned > constexpr size_t extent_v; template < typename _Tp, size_t _Size > size_t extent_v< _Tp[_Size], 0 >; template < typename _Tp, unsigned _Idx, size_t _Size > size_t extent_v < _Tp[_Size], _Idx< 1 >; template < typename _Tp > constexpr size_t extent_v< _Tp, 0 >; template < typename _Tp, unsigned _Idx > size_t extent_v < _Tp, _Idx< 1 >; template < typename _Tp, typename _Up > constexpr bool is_same_v = __is_same(_Tp, _Up); template < typename _From, typename _To > constexpr bool is_convertible_v = is_convertible< _From, _To >::value; template < typename... _Args > bool is_invocable_v = is_invocable< _Args... >::value; template < typename _Fn, typename... _Args > bool is_nothrow_invocable_v = is_nothrow_invocable< _Args... >::value; template < typename _Ret, typename _Fn, typename... _Args > bool is_invocable_r_v = is_invocable_r< _Args... >::value; template < typename _Ret, typename _Fn, typename... _Args > bool is_nothrow_invocable_r_v = is_nothrow_invocable_r< _Args... >::value; template < typename _Tp > struct has_unique_object_representations : bool_constant< __has_unique_object_representations( remove_cv_t< remove_all_extents_t< _Tp > >) > { static_assert(std__is_complete_or_unbounded(__type_identity< _Tp >{})); }; template < typename _Tp > bool has_unique_object_representations_v = has_unique_object_representations< _Tp >::value; template < typename _Tp > struct is_aggregate : bool_constant< __is_aggregate(remove_cv_t< int >) > {}; struct _Bit_iterator; template < typename _Tp > struct remove_cvref : remove_cv< int > {}; template < typename _Tp > struct remove_cvref< _Tp && > : remove_cv< _Tp > {}; template < typename _Tp > using remove_cvref_t = remove_cvref< _Tp >::type; template < typename _Tp > bool is_bounded_array_v; template < typename _Tp, size_t _Size > bool is_bounded_array_v_Tp_Size; constexpr bool is_unbounded_array_v = false; template < typename _From, typename _To > using __copy_cv = __match_cv_qualifiers< _From, _To >::__type; template < typename _Xp, typename _Yp > using __cond_res = decltype(false ? 0 : declval< _Yp (&)() >()()); template < typename _Bp, typename = void > struct __common_ref_impl; template < typename _Ap, typename _Bp > using __common_ref = __common_ref_impl< _Bp >::type; template < typename _Xp, typename _Yp > using __condres_cvref = __cond_res< __copy_cv< _Xp, _Yp > &, __copy_cv< _Yp, _Xp > & >; template < typename _Yp > struct __common_ref_impl< _Yp &, __void_t<> >; template < template < typename > class _UQual > struct basic_common_reference; template < typename _Tp > struct __xref; ; template < typename _Tp1, typename _Tp2 > using __basic_common_ref = basic_common_reference< __xref< _Tp2 >::template __type >::type; template < typename... > struct common_reference; template < typename... _Tp > using common_reference_t = common_reference< _Tp... >::type; template < typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void > struct __common_reference_impl : __common_reference_impl< int, int, _Bullet + 1 > {}; template < typename _Tp1, typename _Tp2 > struct common_reference< _Tp1, _Tp2 > : __common_reference_impl< _Tp1, _Tp2 > {}; template < typename _Tp1, typename _Tp2 > struct __common_reference_impl< _Tp1, _Tp2, 4, void_t<> >; ; template < typename _Tp1, typename _Tp2 > struct __common_reference_impl< _Tp1, _Tp2, 5 >; namespace __detail { template < typename _Tp, typename _Up > concept __same_as = std::is_same_v< _Tp, _Up >; } template < typename _Tp, typename _Up > concept same_as = __detail::__same_as< _Tp, _Up > && __detail::__same_as< _Up, _Tp >; template < typename _Derived, typename _Base > concept derived_from = __is_base_of(_Base, _Derived) && is_convertible_v< _Derived *, volatile _Base * >; template < typename _From, typename _To > concept convertible_to = is_convertible_v< _From, _To > && requires { static_cast< _To >(std::declval< _From >()); }; template < typename _Tp, typename _Up > concept common_reference_with = same_as< common_reference_t< _Tp, _Up >, common_reference_t< _Up, _Tp > > && convertible_to< _Tp, common_reference_t< _Tp, _Up > > && convertible_to< _Up, common_reference_t< _Tp, _Up > >; template < typename _Tp, typename _Up > concept common_with = same_as< common_type_t<>, common_type_t<> > && requires { static_castcommon_type_t(std::declval< _Tp >); static_castcommon_type_t(std::declval< _Up >); } && common_reference_with< add_lvalue_reference_t< _Tp >, add_lvalue_reference_t< const _Up > > && common_reference_with< add_lvalue_reference_t< common_type_t< _Up > >, common_reference_t< add_lvalue_reference_t< const _Tp >, add_lvalue_reference_t< const _Up > > >; template < typename _Tp > concept integral = is_integral_v<>; template < typename _Tp > concept signed_integral = integral< _Tp > && is_signed_v<>; template < typename _Tp > concept unsigned_integral = integral< _Tp > && signed_integral< _Tp >; template < typename _Tp > concept floating_point = is_floating_point_v<>; namespace __detail { template < typename _Tp > using __cref = const remove_reference_t< _Tp > &; template < typename _Tp > concept __class_or_enum = is_class_v<> || is_union_v; } template < typename _Lhs, typename _Rhs > concept assignable_from = is_lvalue_reference_v< _Lhs > && common_reference_with< __detail::__cref< _Lhs >, __detail::__cref< _Rhs > > && requires(_Lhs __lhs, _Rhs &&__rhs) { { __lhs = static_cast< _Rhs >(__rhs) } -> same_as< _Lhs >; }; template < typename _Tp > concept destructible = is_nothrow_destructible_v< _Tp >; template < typename _Tp, typename... _Args > concept constructible_from = destructible< _Tp > && is_constructible_v< _Tp, _Args... >; template < typename _Tp > concept default_initializable = constructible_from< _Tp > && requires { new _Tp; }; template < typename _Tp > concept move_constructible = constructible_from< _Tp > && convertible_to< _Tp, _Tp >; template < typename _Tp > concept copy_constructible = move_constructible< _Tp > && constructible_from< _Tp > && convertible_to< _Tp &, _Tp > && constructible_from< _Tp > && convertible_to< const _Tp &, _Tp > && constructible_from< const _Tp > && convertible_to< const _Tp, _Tp >; namespace ranges { template < typename _Tp, typename _Up > concept __adl_swap = 0 && requires() { swap; }; struct _Swap { template < typename _Tp, typename _Up > static constexpr bool _S_noexcept() { if constexpr (__adl_swap< _Tp, int >) return noexcept(0); return is_nothrow_move_constructible_v<> && is_nothrow_move_assignable_v<>; } template < typename _Tp, typename _Up > requires __adl_swap< _Tp, _Up > || (same_as< _Tp, _Up > &&is_lvalue_reference_v<> &&move_constructible< remove_reference_t< _Tp > > &&assignable_from< _Tp, remove_reference_t< _Tp > >)void operator0() const noexcept(_S_noexcept< _Tp, _Up >()); template < typename _Tp, typename _Up, int _Num > requires requires() { 0; } void operator0(_Tp(__e1), _Up(__e2)) noexcept( noexcept(std::declval< _Swap >()(__e1 *__e2))); }; inline namespace __cust { _Swap swap; } } template < typename _Tp > concept swappable = requires() { ranges::swap; }; template < typename _Tp, typename _Up > concept swappable_with = common_reference_with< _Tp, _Up > && requires(_Tp &&__t, _Up &&__u) { rangesswap(static_cast_Tp(__t), static_cast_Tp(__t)); rangesswap(static_cast_Up(__u), static_cast_Tp(__t)); }; template < typename _Tp > concept movable = is_object_v< _Tp > && move_constructible< _Tp > && assignable_from< _Tp &, _Tp > && swappable< _Tp >; template < typename _Tp > concept copyable = copy_constructible< _Tp > && movable< _Tp > && assignable_from< _Tp &, _Tp & > && assignable_from< _Tp &, const _Tp & > && assignable_from< _Tp &, const _Tp >; template < typename _Tp > concept semiregular = copyable< _Tp > && default_initializable< _Tp >; namespace __detail { template < typename _Tp > concept __boolean_testable_impl = convertible_to< _Tp, bool >; template < typename _Tp > concept __boolean_testable = __boolean_testable_impl< _Tp > && requires(_Tp &&__t) { { !static_cast< _Tp >(__t) } -> __boolean_testable_impl; }; template < typename _Tp, typename _Up > concept __weakly_eq_cmp_with = requires(__detail::__cref< _Tp > __t, __detail::__cref< _Up > __u) { { __t == __u } -> __boolean_testable; { __u != __t } -> __boolean_testable; }; } template < typename _Tp > concept equality_comparable = __detail::__weakly_eq_cmp_with< _Tp, _Tp >; template < typename _Tp, typename _Up > concept equality_comparable_with = equality_comparable< _Tp > && equality_comparable< _Up > && common_reference_with< __detail::__cref< _Tp >, __detail::__cref< _Up > > && equality_comparable< common_reference_t< __detail::__cref< _Tp >, __detail::__cref< _Up > > > && __detail::__weakly_eq_cmp_with< _Tp, _Up >; namespace __detail { template < typename _Tp, typename _Up > concept __partially_ordered_with = requires(remove_reference_t< _Tp > __t, remove_reference_t< _Up > __u) { __u <= __t->__boolean_testable; __u >= __t->__boolean_testable; }; } template < typename _Tp > concept totally_ordered = equality_comparable< _Tp > && __detail::__partially_ordered_with< _Tp, _Tp >; template < typename _Tp, typename _Up > concept totally_ordered_with = totally_ordered< _Tp > && totally_ordered< _Up > && equality_comparable_with< _Tp, _Up > && totally_ordered< common_reference_t< __detail::__cref< _Tp >, __detail::__cref< _Up > > > && __detail::__partially_ordered_with< _Tp, _Up >; template < typename _Tp > concept regular = semiregular< _Tp > && equality_comparable< _Tp >; template < typename _Fn, typename... _Args > concept invocable = is_invocable_v<>; template < typename _Fn, typename... _Args > concept regular_invocable = invocable< _Fn, _Args... >; template < typename _Fn, typename... _Args > concept predicate = regular_invocable< _Fn, _Args... > && __detail::__boolean_testable< invoke_result_t< _Fn, _Args... > >; template < typename _Rel, typename _Tp, typename _Up > concept relation = predicate< _Rel, _Tp, _Tp > && predicate< _Rel, _Up, _Up > && predicate< _Rel, _Tp, _Up > && predicate< _Rel, _Up, _Tp >; template < typename _Rel, typename _Tp, typename _Up > concept equivalence_relation = relation< _Rel, _Tp, _Up >; template < typename _Rel, typename _Tp, typename _Up > concept strict_weak_order = relation< _Rel, _Tp, _Up >; template < typename _Tp >[[]] _Tp &&forward() noexcept; template < typename _Tp >[[]] _Tp &&forward() noexcept; template < typename _Tp >[[]] remove_reference< _Tp >::type &&move() noexcept; template < typename _Tp > struct __move_if_noexcept_cond : __and_<>::type {}; template < typename _Tp > [[]] __conditional_t< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp && > move_if_noexcept() noexcept; template < typename _Tp >[[]] _Tp *addressof() noexcept; class __undefined; template < typename > struct __get_first_arg; ; template < typename > struct __replace_first_arg; ; template < template < typename, typename... > class _SomeTemplate, typename _Tp, typename... _Types > struct __replace_first_arg< _SomeTemplate< _Tp, _Types... > >; ; template < typename _Ptr > using __ptr_traits_elem_t = __get_first_arg< _Ptr >; # 9 "" 3 template < typename _Ptr, typename _Elt, bool = is_void< _Elt >::value > struct __ptr_traits_ptr_to; ; template < typename _Ptr, typename _Elt > struct __ptr_traits_ptr_to< _Ptr, _Elt >; ; template < typename _Tp > struct __ptr_traits_ptr_to< _Tp, _Tp >; ; template < typename _Elt > struct __ptr_traits_impl : __ptr_traits_ptr_to< int, _Elt > { template < typename = void > struct __difference; ; template < typename _Tp > struct __difference_Tp; ; template < typename, typename, typename = void > struct __rebind; ; template < typename _Tp, typename _Up > struct __rebind< _Tp, _Up >; ; }; template <> struct __ptr_traits_impl< int >; ; template < typename _Ptr > struct pointer_traits : __ptr_traits_impl< __ptr_traits_elem_t< _Ptr > > {}; template < typename _Ptr > requires requires { typename _Ptr::element_type; } struct pointer_traits_Ptr; ; template < typename _Tp > struct pointer_traits< _Tp * > : __ptr_traits_ptr_to< _Tp, _Tp > {}; template < typename _Ptr, typename... _None > void __to_address() noexcept; template < typename _Ptr > void to_address(const _Ptr &) noexcept; struct __is_transparent; struct identity; ; namespace ranges { namespace __detail { template < typename _Tp, typename _Up > concept __less_builtin_ptr_cmp = requires(_Tp &&__t, _Up &&__u) { { __t < __u } -> same_as< bool >; } &&convertible_to< _Tp, void > &&convertible_to< _Up, void > && 0; } struct not_equal_to; ; struct less; ; } struct default_sentinel_t {}; struct input_iterator_tag; struct output_iterator_tag; struct bidirectional_iterator_tag; struct random_access_iterator_tag; struct contiguous_iterator_tag; template < typename _Iterator > struct iterator_traits; template < typename _Tp > requires is_object_v<> struct iterator_traits< _Tp * >; template < typename _Iterator, typename > struct __iterator_traits; namespace __detail { template < typename _Tp > using __with_ref = _Tp &; template < typename _Tp > concept __can_reference = requires { typename __with_ref< _Tp >; }; template < typename _Tp > concept __dereferenceable = requires(_Tp &__t) { *__t->__can_reference; }; } template < __detail::__dereferenceable _Tp > using iter_reference_t = decltype(*std::declval< _Tp & >()); namespace ranges { namespace __cust_imove { template < typename _Tp > concept __adl_imove = 0 && requires(_Tp &&__t) { iter_move(static_cast< _Tp && >(__t)); }; struct _IMove { template < typename _Tp > struct __result; ; template < typename _Tp > requires __adl_imove_Tp struct __result_Tp; ; template < typename _Tp > requires(__adl_imove< _Tp >) && is_lvalue_reference_v<> struct __result< _Tp >; ; template < std::__detail::__dereferenceable _Tp > using __type = __result< _Tp >::type; ; }; inline constexpr __cust_imove::_IMove iter_move; ; } } template < __detail::__dereferenceable _Tp > requires __detail::__can_reference< ranges::__cust_imove::_IMove::__type< _Tp > > using iter_rvalue_reference_t = ranges::__cust_imove::_IMove::__type< _Tp & >; template < typename > struct incrementable_traits; ; template < typename _Iter > struct incrementable_traits< const _Iter >; ; template < typename _Tp > requires requires { typename _Tp; } struct incrementable_traits< _Tp > { using difference_type = _Tp::difference_type; }; template < typename _Tp > requires( !requires { typename _Tp::difference_type; } && requires(_Tp & __a, const _Tp &__b) { -__b->integral; }) struct incrementable_traits_Tp; ; namespace __detail { template < typename _Iter > concept __primary_traits_iter = __is_base_of(__iterator_traits< _Iter, void >, iterator_traits< _Iter >); template < typename, typename > struct __iter_traits_impl; ; template < typename _Iter, typename _Tp > requires __primary_traits_iter< _Iter > struct __iter_traits_impl< _Iter, _Tp > { using type = _Tp; }; template < typename _Iter, typename _Tp = _Iter > using __iter_traits = __iter_traits_impl< _Iter, _Tp >::type; template < typename _Tp > using __iter_diff_t = __iter_traits< incrementable_traits< _Tp > >::difference_type; } template < typename _Tp > using iter_difference_t = __detail::__iter_diff_t< remove_cvref_t< _Tp > >; namespace __detail { template < typename > struct __cond_value_type; ; template < typename _Tp > requires is_object_v<> struct __cond_value_type_Tp; ; template < typename _Tp > concept __has_member_value_type = requires { typename _Tp::value_type; }; template < typename _Tp > concept __has_member_element_type = requires { typename _Tp::element_type; }; } template < typename > struct indirectly_readable_traits; ; template < typename _Tp > struct indirectly_readable_traits< _Tp * >; ; template < typename _Iter > requires is_array_v<> struct indirectly_readable_traits_Iter; ; template < __detail::__has_member_value_type _Tp > requires __detail::__has_member_element_type< _Tp > struct indirectly_readable_traits_Tp; ; namespace __detail { template < typename _Tp > using __iter_value_t = __iter_traits< indirectly_readable_traits< _Tp > >::value_type; } template < typename _Tp > using iter_value_t = __detail::__iter_value_t< remove_cvref_t< _Tp > >; namespace __detail { template < typename _Iter > concept __cpp17_iterator = requires(_Iter __it) { *__it++->__can_reference; } &©able< _Iter >; template < typename _Iter > concept __cpp17_input_iterator = __cpp17_iterator< _Iter > && requires(_Iter __it) { typename common_reference_t< iter_reference_t< _Iter >, typename indirectly_readable_traits< _Iter >::value_type >; typename common_reference_t< decltype(__it++) &&, typename indirectly_readable_traits< _Iter >::value_type & >; signed_integral< typename incrementable_traits< _Iter >::difference_type >; }; template < typename _Iter > concept __cpp17_fwd_iterator = __cpp17_input_iterator< _Iter > && same_as < remove_cvref_t< iter_reference_t< _Iter > >, typename indirectly_readable_traits< _Iter >::value_type > &&requires(_Iter __it) { { *__it++ } -> same_as< iter_reference_t< _Iter > >; }; template < typename _Iter > concept __cpp17_bidi_iterator = __cpp17_fwd_iterator< _Iter > && requires(_Iter __it) { { *__it-- } -> convertible_to< iter_reference_t< _Iter > >; }; template < typename _Iter > concept __iter_with_nested_types = requires { typename _Iter::reference; }; template < typename _Iter > concept __iter_without_nested_types = !__iter_with_nested_types< _Iter >; template < typename _Iter > concept __iter_without_category = !requires { typename _Iter::iterator_category; }; } template < typename _Iterator > struct __iterator_traits< _Iterator, void > { template < typename > struct __ptr { using type = void; }; template < typename _Iter > requires requires { _Iter::pointer; } struct __ptr_Iter; ; using iterator_category = _Iterator::iterator_category; using value_type = _Iterator::value_type; using difference_type = _Iterator::difference_type; using pointer = __ptr< _Iterator >::type; using reference = _Iterator::reference; }; template < typename _Iterator > requires __detail::__iter_without_nested_types< _Iterator > struct __iterator_traits< _Iterator, void > { template < typename > struct __cat; ; template < typename _Iter > requires requires { _Iter::iterator_category; } struct __cat_Iter; ; template < typename _Iter > requires __detail::__iter_without_category< _Iter > struct __cat< _Iter >; ; template < typename _Iter > requires __detail::__iter_without_category< _Iter > && __detail::__cpp17_bidi_iterator< _Iter > struct __cat< _Iter >; ; template < typename > struct __ptr; ; template < typename _Iter > requires requires { _Iter::pointer; } struct __ptr_Iter; ; template < typename _Iter > requires( requires { _Iter::pointer; } && requires(_Iter & __it) { __it; }) struct __ptr< _Iter >; ; template < typename _Iter > struct __ref; ; template < typename _Iter > requires requires { _Iter::reference; } struct __ref_Iter; ; }; namespace __detail { template < typename > struct __iter_concept_impl; template < typename _Iter > requires requires { __iter_traits< _Iter >::iterator_concept; } struct __iter_concept_impl_Iter; ; template < typename _Iter > requires( !requires { __iter_traits< _Iter >::iterator_concept; } && requires { typename __iter_traits< _Iter >; }) struct __iter_concept_impl< _Iter > { using type = __iter_traits< _Iter >::iterator_category; }; template < typename _Iter > requires( requires { __iter_traits< _Iter >::iterator_concept; } && requires { __iter_traits< _Iter >::iterator_category; } && __primary_traits_iter< _Iter >) struct __iter_concept_impl< _Iter >; ; template < typename _Iter > using __iter_concept = __iter_concept_impl< _Iter >::type; template < typename _In > concept __indirectly_readable_impl = requires { same_as< iter_reference_t< const _In >, iter_reference_t< _In > >; same_as< iter_rvalue_reference_t< const _In >, iter_rvalue_reference_t< _In > >; } &&common_reference_with< iter_reference_t< _In >, iter_rvalue_reference_t< _In > > &&common_reference_with< iter_rvalue_reference_t< _In >, const iter_value_t< _In > & >; } template < typename _In > concept indirectly_readable = __detail::__indirectly_readable_impl< remove_cvref_t< _In > >; template < indirectly_readable _Tp > using iter_common_reference_t = common_reference_t< iter_reference_t< _Tp >, iter_value_t< _Tp > & >; template < typename _Out, typename _Tp > concept indirectly_writable = requires(_Out &&__o, _Tp &&__t) { const_castiter_reference_t_Out(*__o) > 0; const_cast< const iter_reference_t< _Out > && >(*std::forward(__o)) = std::forward(__t); }; namespace ranges::__detail { class __max_diff_type; class __max_size_type; template < typename _Tp > concept __is_signed_int128 = same_as< _Tp, __int128 >; template < typename _Tp > concept __is_unsigned_int128 = same_as< _Tp, __int128 >; template < typename _Tp > concept __cv_bool = same_as< const volatile _Tp, volatile >; template < typename _Tp > concept __integral_nonbool = integral< _Tp > && __cv_bool< _Tp >; template < typename _Tp > concept __is_int128 = __is_signed_int128< _Tp > || __is_unsigned_int128< _Tp >; template < typename _Tp > concept __is_integer_like = __integral_nonbool< _Tp > || same_as< _Tp, __max_diff_type > || same_as< _Tp, __max_size_type >; template < typename _Tp > concept __is_signed_integer_like = signed_integral< _Tp > || same_as< _Tp, __max_diff_type >; using __detail::__is_signed_integer_like; } template < typename _Iter > concept weakly_incrementable = movable< _Iter > && requires(_Iter __i) { __i++; }; template < typename _Iter > concept incrementable = regular< _Iter > && weakly_incrementable< _Iter > && requires(_Iter __i) { { __i++ } -> same_as< _Iter >; }; template < typename _Iter > concept input_or_output_iterator = requires(_Iter __i) { { *__i } -> __detail::__can_reference; } &&weakly_incrementable< _Iter >; template < typename _Sent, typename _Iter > concept sentinel_for = semiregular< _Sent > && __detail::__weakly_eq_cmp_with< _Sent, _Iter >; template <> bool disable_sized_sentinel_for; template < typename _Sent, typename _Iter > concept sized_sentinel_for = sentinel_for< _Sent, _Iter > && requires(const _Iter &__i, const _Sent &__s) { { __i - __s } -> same_as< iter_difference_t< _Iter > >; }; template < typename _Iter > concept input_iterator = input_or_output_iterator< _Iter > && derived_from< __detail::__iter_concept< _Iter >, input_iterator_tag >; template < typename _Iter, typename _Tp > concept output_iterator = input_or_output_iterator< _Iter > && requires(_Iter __i, _Tp &&__t) { *__i++ = std::forward(__t); }; template < typename _Iter > concept forward_iterator = input_iterator< _Iter > && incrementable< _Iter > && sentinel_for< _Iter, _Iter >; template < typename _Iter > concept bidirectional_iterator = forward_iterator< _Iter > && derived_from< __detail::__iter_concept< _Iter >, bidirectional_iterator_tag > && requires(_Iter __i) { { __i-- } -> same_as< _Iter >; }; template < typename _Iter > concept random_access_iterator = bidirectional_iterator< _Iter > && derived_from< __detail::__iter_concept< _Iter >, random_access_iterator_tag > && requires(_Iter, const _Iter __j, const iter_difference_t< _Iter > __n) { { __j[__n] } -> same_as< iter_reference_t< _Iter > >; }; template < typename _Iter > concept contiguous_iterator = random_access_iterator< _Iter > && requires(const &__i) { { std::to_address(__i) } -> same_as< add_pointer_t< iter_reference_t< _Iter > > >; }; template < typename _Fn, typename _Iter > concept indirectly_unary_invocable = indirectly_readable< _Iter > && common_reference_with < invoke_result_t < _Fn &, iter_value_t< _Iter > & >, invoke_result_t < _Fn &, iter_reference_t < _Iter >>> ; template < typename _Fn, typename _Iter > concept indirectly_regular_unary_invocable = indirectly_readable< _Iter > && common_reference_with < invoke_result_t < _Fn &, iter_value_t< _Iter > & >, invoke_result_t < _Fn &, iter_reference_t < _Iter >>> ; template < typename _Iter > concept indirect_unary_predicate = indirectly_readable< _Iter > && predicate< iter_common_reference_t< _Iter > >; template < typename _Fn, typename _I1, typename _I2 > concept indirect_binary_predicate = indirectly_readable< _I1 > && indirectly_readable< _I2 > && predicate< _Fn, iter_common_reference_t< _I1 >, iter_common_reference_t< _I2 > >; template < typename _Fn, typename _I1, typename _I2 > concept indirect_equivalence_relation = indirectly_readable< _I1 > && indirectly_readable< _I2 > && equivalence_relation< _Fn, iter_reference_t< _I1 >, iter_reference_t< _I2 > > && equivalence_relation< _Fn, iter_common_reference_t< _I1 >, iter_common_reference_t< _I2 > >; template < typename _Fn, typename _I1, typename _I2 = _I1 > concept indirect_strict_weak_order = indirectly_readable< _I1 > && indirectly_readable< _I2 > && strict_weak_order< _Fn, iter_common_reference_t< _I1 >, iter_common_reference_t< _I2 > >; template < typename _Fn, typename... _Is > requires(indirectly_readable< _Is > &&...) using indirect_result_t = invoke_result_t< _Fn, iter_reference_t< _Is >... >; template < indirectly_readable _Iter, indirectly_regular_unary_invocable< _Iter > > struct projected; ; template < weakly_incrementable _Iter, typename _Proj > struct incrementable_traits< projected< _Iter, _Proj > >; ; template < typename _In, typename _Out > concept indirectly_movable = indirectly_readable< _In > && indirectly_writable< _Out, iter_rvalue_reference_t< _In > >; template < typename _In, typename _Out > concept indirectly_movable_storable = indirectly_movable< _In, _Out > && assignable_from< iter_value_t< _In >, iter_rvalue_reference_t< _In > >; template < typename _In, typename _Out > concept indirectly_copyable = indirectly_readable< _In > && indirectly_writable< _Out, iter_reference_t< _In > >; template < typename _In, typename _Out > concept indirectly_copyable_storable = indirectly_copyable< _In, _Out > && assignable_from< iter_value_t< _In >, iter_reference_t< _In > >; namespace ranges { template < typename _Tp, typename _Up > concept __adl_iswap = 0 && requires(_Tp &&__t, _Up &&__u) { 0; }; struct _IterSwap { template < typename _Tp, typename _Up > requires __adl_iswap< _Tp, _Up > ||( indirectly_readable< remove_reference_t< _Tp > > && swappable_with< iter_reference_t< _Tp >, iter_reference_t< _Up > >) || (indirectly_movable_storable< _Tp, _Up > && indirectly_movable_storable< _Up, _Tp >)operator0(_Tp &&__e1, _Up &&__e2) { if (__adl_iswap< _Tp, _Up >) 0; if (indirectly_readable< _Tp > && swappable_with< iter_reference_t< _Tp >, iter_reference_t< _Up > > * __e1 * __e2) ; } }; _IterSwap Trans_NS___cust_iter_swap; } template < typename _I1, typename _I2 = _I1 > concept indirectly_swappable = indirectly_readable< _I1 > && indirectly_readable< _I2 > && requires(_I1 __i1) { rangesiter_swap(__i1); }; template < typename _I1, typename _I2, typename _Rel, typename _P1, typename _P2 > concept indirectly_comparable = indirect_binary_predicate< _Rel, projected< _I1, _P1 >, projected< _I2, _P2 > >; template < typename _Iter > concept permutable = forward_iterator< _Iter > && indirectly_swappable< _Iter >; template < typename _I1, typename _I2 = ranges::less, typename _P1 = identity, typename _P2 = identity > concept mergeable = input_iterator< _I1 > && input_iterator< _I2 > && indirect_strict_weak_order< projected< _I1, _P1 >, projected< _I2, _P2 > >; template < typename _Iter, typename _Rel = ranges::less, typename _Proj = identity > concept sortable = permutable< _Iter > && indirect_strict_weak_order< _Rel, projected< _Iter, _Proj > >; struct unreachable_sentinel_t {} unreachable_sentinel; namespace ranges::__cust_access { using std::__detail::__class_or_enum; struct _Decay_copy; ; template < typename _Tp > concept __member_begin = requires(_Tp &__t) { 0; }; template < typename _Tp > void __begin(); } namespace __detail { template < typename _Tp > using __range_iter_t = decltype(ranges::__cust_access::__begin(declval< _Tp >)); } struct input_iterator_tag {}; struct forward_iterator_tag : input_iterator_tag {}; struct bidirectional_iterator_tag : forward_iterator_tag {}; struct random_access_iterator_tag : bidirectional_iterator_tag {}; template < typename _Pointer = int > struct iterator { typedef int iterator_category; typedef int value_type; typedef int difference_type; }; template < typename > struct iterator_traits; template < typename, typename = __void_t<> > struct __iterator_traits; template < typename _Iterator > struct iterator_traits : __iterator_traits< int > {}; template < typename _Tp > requires is_object_v< _Tp > struct iterator_traits< _Tp * > { using iterator_category = random_access_iterator_tag; using value_type = remove_cv_t< _Tp >; using difference_type = ptrdiff_t; using pointer = _Tp; using reference = _Tp; }; template < typename _Iter > iterator_traits< _Iter > __iterator_category; template < typename _Iter > using __iterator_category_t = iterator_traits< _Iter >; template < typename _InIter > using _RequireInputIter = __enable_if_t< is_convertible< __iterator_category_t< _InIter >, int >::value >; template < typename _It, typename _Cat = __iterator_category_t< _It > > struct __is_random_access_iter; ; } namespace std __attribute__(()) { struct __true_type; template < typename, typename > struct __are_same { enum { __value }; }; template < typename _Tp > struct __are_same< _Tp, _Tp > { enum { __value }; }; template < typename > struct __is_integer; ; template <> struct __is_integer< int > { enum { __value = 1 }; }; template <> struct __is_integer< long >; ; template <> struct __is_integer< unsigned >; ; template < typename > struct __is_scalar; template < typename _Tp > struct __is_char; template < typename _Tp > struct __is_byte; enum byte : char; struct __is_bytebyte; struct __memcmpable; template < typename _Tp, bool _TreatAsBytes = __is_byte< _Tp >::__value > struct __is_memcmp_ordered; template < typename _Tp, typename _Up > struct __is_memcmp_ordered_with; ; template < typename > struct __is_move_iterator; } namespace __gnu_cxx __attribute__(()) { template < int, typename > struct __enable_if; template < typename _Tp > struct __enable_if< true, _Tp >; template < int, typename _Iftrue, typename > struct __conditional_type; template < typename _Iftrue, typename _Iffalse > struct __conditional_type< false, _Iftrue, _Iffalse >; template < typename _Tp > struct __add_unsigned; ; struct __remove_unsigned; ; template < typename > struct __promote; template <> struct __promote< long >; template <> struct __promote< double >; template <> struct __promote< float >; template < typename... _Tp > using __promoted_t = decltype(0); template < typename _Up > using __promote_2 = __promote< __promoted_t< _Up > >; template < typename _Vp > using __promote_3 = __promote< __promoted_t< _Vp > >; template < typename _Wp > using __promote_4 = __promote< __promoted_t< _Wp > >; } const unsigned int __common_cmp_cat___cats = 0; namespace std __attribute__(()) { namespace __cmp_cat { using type = char; enum _Ord { equivalent, less, greater }; enum _Ncmp { _Unordered }; struct __unspec; ; } struct partial_ordering { char _M_value; constexpr partial_ordering(__cmp_cat::_Ord __v) : _M_value() {} static const partial_ordering less; static const partial_ordering equivalent; static const partial_ordering greater; static const partial_ordering unordered; } partial_orderingless(__cmp_cat::less); constexpr partial_ordering partial_orderingequivalent(__cmp_cat::equivalent); struct weak_ordering { signed char _M_value; constexpr weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value() {} static const weak_ordering less; static const weak_ordering equivalent; static const weak_ordering greater; } weak_orderingless(__cmp_cat::less); struct strong_ordering { __cmp_cat::type _M_value; constexpr strong_ordering(__cmp_cat::_Ord __v) noexcept : _M_value() {} static const strong_ordering less; static const strong_ordering equal; static const strong_ordering equivalent; static const strong_ordering greater; friend constexpr strong_ordering operator>(strong_ordering __v, __cmp_cat::__unspec); friend constexpr strong_ordering operator>(__cmp_cat::__unspec, strong_ordering __v) noexcept; } strong_orderingless(__cmp_cat::less); namespace __detail { template < typename _Tp > constexpr unsigned __cmp_cat_id; template <> constexpr unsigned __cmp_cat_id< partial_ordering > = 2; template <> inline unsigned __cmp_cat_id; template <> inline constexpr unsigned __cmp_cat_id< strong_ordering > = 8; template < typename... _Ts > auto __common_cmp_cat() { if constexpr (0 & 1) return; else { bool(); return partial_orderingequivalent; } } } template < typename... _Ts > struct common_comparison_category { using type = decltype(__detail::__common_cmp_cat< _Ts... >()); }; template < typename _Tp > struct common_comparison_category_Tp; ; template <> struct common_comparison_category<>; ; struct common_comparison_category<>; template < typename... _Ts > using common_comparison_category_t = common_comparison_category< _Ts... >::type; namespace __detail { template < typename _Tp, typename _Cat > concept __compares_as = same_as< common_comparison_category_t< _Tp, _Cat >, _Cat >; } template < typename _Tp, typename _Cat > concept three_way_comparable = __detail::__weakly_eq_cmp_with< _Tp, _Tp > && requires(remove_reference_t< _Tp > __a, remove_reference_t< _Tp > __b) { { __a > __b } -> __detail::__compares_as< _Cat >; }; template < typename _Tp, typename _Up, typename _Cat = partial_ordering > concept three_way_comparable_with = three_way_comparable< _Tp, _Cat > && common_reference_with< remove_reference_t< _Tp >, remove_reference_t< _Up > > && three_way_comparable < common_reference_t < remove_reference_t< _Tp >, remove_reference_t< _Up > & >, _Cat > &&requires(remove_reference_t< _Tp > __t, remove_reference_t< _Up > __u) { { __u > __t } -> __detail::__compares_as< _Cat >; }; namespace __detail { template < typename _Tp, typename _Up > using __cmp3way_res_t = decltype(declval < _Tp >> declval); template < typename, typename > struct __cmp3way_res_impl; template < typename _Tp, typename _Up > requires requires { typename __cmp3way_res_t< __cref< _Tp >, __cref< _Up > >; } struct __cmp3way_res_impl< _Tp, _Up >; } struct compare_three_way_result; template < typename _Tp, typename _Up > using compare_three_way_result_t = __detail::__cmp3way_res_impl< _Tp, _Up >; namespace __detail { template < typename _Tp, typename _Up > concept __3way_builtin_ptr_cmp = requires(_Tp &&__t, _Up &&__u) { 0 > 0; } &&!requires(_Tp && __t, _Up &&__u) { (0, static_cast_Up(__u)); } &&!requires(_Tp && __t, _Up &&__u) { static_cast_Tp(__tstatic_cast(__u)); }; } struct compare_three_way { template < typename _Tp, typename _Up > requires three_way_comparable_with< _Tp, _Up > auto operator0(_Tp &&__t, _Up &&__u) { if (__detail::__3way_builtin_ptr_cmp< _Tp, _Up >) ; } }; template < floating_point _Tp > weak_ordering __fp_weak_ordering; template < typename _Tp, typename _Up > concept __adl_strong = requires(_Tp && __t, _Up && __u) { (strong_order(static_cast_Tp(__t) > 0)); }; template < typename _Tp, typename _Up > concept __adl_weak = requires(_Tp && __t, _Up && __u) { (weak_order((__u))); }; template < typename _Tp, typename _Up > concept __adl_partial = requires(_Tp && __t, _Up && __u) { (partial_order((__u))); }; template < typename, typename _Tp, typename _Up > concept __cmp3way = requires(_Tp && __t, _Up && __u) { ((static_cast_Tp(__t), static_cast_Up(__u))); }; template < typename _Tp, typename _Up > concept __strongly_ordered = __adl_strong< _Tp, _Up > || __cmp3way< strong_ordering, _Tp, _Up >; template < typename _Tp, typename _Up > concept __decayed_same_as = same_as< decay_t< _Tp >, decay_t< _Up > >; struct _Strong_order; ; template < typename _Tp, typename _Up > concept __weakly_ordered = floating_point< remove_reference_t< _Tp > > || __strongly_ordered< _Tp, _Up >; struct _Weak_order; template < typename _Tp, typename _Up > concept __partially_ordered = __adl_partial< _Tp, _Up > || __weakly_ordered< _Tp, _Up >; struct _Partial_order; template < typename _Tp, typename _Up > concept __op_eq_lt = requires(_Tp && __t, _Up && __u) { { static_cast_Tp(__t) == static_cast_Up(__u) } -> convertible_to< bool >; { static_cast_Tp(__t) < static_cast_Up(__u) } -> convertible_to< bool >; }; struct _Strong_fallback; struct _Weak_fallback; ; template < typename _Tp, typename _Up > concept __op_eq_lt_lt = __op_eq_lt< _Tp, _Up > && requires(_Tp && __t, _Up && __u) { { static_cast_Up(__u) < static_cast_Tp(__t) } -> convertible_to< bool >; }; struct _Partial_fallback; ; namespace __detail { struct _Synth3way { template < typename _Tp, typename _Up > void operator()(_Tp &__t, _Up &__u) requires requires { __t; }; } __synth3way; template < typename _Tp, typename _Up = _Tp > using __synth3way_t = decltype(0); } struct bad_array_new_length {}; struct nothrow_t; typedef(*new_handler); new_handler get_new_handler; } void *operator new(std::size_t) __attribute__(()); void operator delete(void *) __attribute__(()); void *operator new(unsigned long, void *); void *operator new(std::size_t, void *__p); namespace std { size_t hardware_destructive_interference_size; size_t hardware_constructive_interference_size; struct _Destroy_aux; ; template < int > struct _Destroy_n_aux; ; template <> struct _Destroy_n_aux< true >; ; } namespace std __attribute__(()) { namespace __detail { template < typename _Cat, typename _Limit, typename _Otherwise = _Cat > using __clamp_iter_cat = __conditional_t< derived_from< _Cat, _Limit >, _Limit, _Otherwise >; } #pragma GCC diagnostic "" template < typename _Iterator > struct reverse_iterator : iterator<> { template < typename _Iter > static constexpr bool __convertible = is_same_v<> &&convertible_to< _Iter, _Iterator >; typedef _Iterator __traits_type; typedef __traits_type::pointer pointer; using iterator_concept = __conditional_t< random_access_iterator< _Iterator >, random_access_iterator_tag, bidirectional_iterator_tag >; using iterator_category = __detail::__clamp_iter_cat< typename __traits_type::iterator_category, random_access_iterator_tag >; using difference_type = iter_difference_t< _Iterator >; }; template < typename _IteratorL, typename _IteratorR > operator==(reverse_iterator< _IteratorL >, reverse_iterator< _IteratorR >) {} template < typename _IteratorL, typename _IteratorR > operator!=(reverse_iterator< _IteratorL >, reverse_iterator< _IteratorR >) {} template < typename _Iterator > operator==(reverse_iterator< _Iterator >, reverse_iterator< _Iterator > &) {} template < typename > struct back_insert_iterator; ; template < typename _Container > struct front_insert_iterator; ; template < typename _Container > struct insert_iterator; ; template < typename _Container > inserter(__detail::__range_iter_t< _Container > __i) { _Container &__x; insert_iterator(__x, __i); } } namespace __gnu_cxx __attribute__(()) { template < typename _Iterator, typename _Container > struct __normal_iterator { typedef _Iterator __traits_type; template < typename _Iter > using __convertible_from = std::__enable_if_t< std::is_convertible< _Iter, _Iterator >::value >; typedef __traits_type::difference_type difference_type; typedef __traits_type::reference reference; typedef __traits_type::pointer pointer; __normal_iterator(_Iterator &) noexcept {} reference operatornoexcept; }; template < typename _IteratorL, typename _IteratorR, typename _Container > operator==( __normal_iterator< _IteratorL, _Container > __lhs, __normal_iterator< _IteratorR, _Container > __rhs) requires requires { { __lhs } -> std::convertible_to< bool >; } { __lhs; } template < typename _IteratorL, typename _IteratorR, typename _Container > operator>(__normal_iterator< _IteratorL, _Container >, __normal_iterator< _IteratorR, _Container >) {} template < typename _IteratorL, typename _IteratorR, typename _Container > auto operator-( const __normal_iterator< _IteratorL, _Container > &__lhs, const __normal_iterator< _IteratorR, _Container > &__rhs) noexcept; template < typename _Iterator, typename _Container > operator-(__normal_iterator< _Iterator, _Container > __lhs, __normal_iterator< _Iterator, _Container > __rhs) { __lhs; } template < typename _Iterator, typename _Container > operator+( typename __normal_iterator< _Iterator, _Container >::difference_type __n, const __normal_iterator< _Iterator, _Container > &__i) { __normal_iterator< int, int >(); } } namespace std __attribute__(()) { template < semiregular _Sent > struct move_sentinel; ; namespace __detail { template < typename _Iterator > struct __move_iter_cat; template < typename _Iterator > requires requires { iterator_traits< _Iterator >::iterator_category; } struct __move_iter_cat_Iterator; ; } template < typename _Iterator > struct move_iterator; ; template < typename _IteratorL, typename _IteratorR > operator==(move_iterator< _IteratorL >, move_iterator< _IteratorR >) {} template < typename _IteratorL, three_way_comparable_with< _IteratorL > _IteratorR > operator>(move_iterator< _IteratorL > __x, move_iterator< _IteratorR > __y) { __x; } template < typename _IteratorL, typename _IteratorR > operator<(move_iterator< _IteratorL >, move_iterator< _IteratorR > &) {} template < typename _IteratorL, typename _IteratorR > void operator-(move_iterator< _IteratorL >, const move_iterator< _IteratorR > __y); template < typename _Iterator > operator+(typename move_iterator< _Iterator >::__nmove_iterator &) {} template < typename _Iterator > make_move_iterator() { _Iterator __i; move_iterator(stdmove(__i)); } template < typename _Iterator, __conditional_t< __move_if_noexcept_cond< typename iterator_traits< _Iterator >::value_type >::value, _Iterator, move_iterator< _Iterator > > > __make_move_if_noexcept_iterator() {} template < typename _Tp, __conditional_t< __move_if_noexcept_cond< _Tp >::value, const, move_iterator< _Tp * > > > __make_move_if_noexcept_iterator() {} namespace __detail { template < typename _It > concept __common_iter_has_arrow = indirectly_readable< _It > && (requires(const _It &__it) { __it; } || constructible_from< iter_value_t< _It >, iter_reference_t< _It > >); template < typename _It > concept __common_iter_use_postfix_proxy = (!requires(_It & __i) { *__i++; }) && move_constructible< iter_value_t< _It > >; } template < input_or_output_iterator _It, sentinel_for< _It > _Sent > class common_iterator; ; namespace __detail { template < typename _It > struct __counted_iter_value_type; template < indirectly_readable _It > struct __counted_iter_value_type_It; ; template < typename _It > struct __counted_iter_cat; template < typename _It > requires requires { _It::iterator_category; } struct __counted_iter_cat_It; ; } template < input_or_output_iterator _It > struct counted_iterator : __detail::__counted_iter_value_type< _It >::__counted_iter_cat { template < typename _It2 > void operator=(counted_iterator); base() const &; base() &&; template < indirectly_swappable _It2 > iter_swap() {} iter_difference_t< _It > _M_length; }; template < input_iterator _It > struct iterator_traits< counted_iterator< _It > > : iterator_traits< _It > { using pointer = __conditional_t< contiguous_iterator< _It >, add_pointer_t< iter_reference_t< _It > >, void >; }; template < typename _Iterator > void __niter_base(); template < typename _Iterator > struct __is_move_iterator< move_iterator< _Iterator > >; template < typename _InputIterator > using __iter_key_t = remove_const_t< typename iterator_traits< _InputIterator >::value_typefirst_type >; template < typename _InputIterator > using __iter_val_t = iterator_traits< _InputIterator >::value_typesecond_type; template < typename _T2 > struct pairvoid __throw_bad_array_new_length __attribute__(()); void __throw_logic_error(char) __attribute__(()); void __throw_length_error(); void __throw_ios_failure(); void __throw_future_error() __attribute__(()); } namespace __gnu_cxx __attribute__(()) { template < typename _Tp > struct __is_integer_nonstrict { std::__is_integer< int >::__value; enum { __width = __value ? sizeof(int) : 0 }; }; template < typename _Value > struct __numeric_traits_integer { static_assert(__is_integer_nonstrict< _Value >::__value); static const bool __is_signed = 0; static const int __digits = __is_integer_nonstrict< _Value >::__width; static const _Value __max = 0 ?: ~0; static const _Value __min = 0; }; template < typename _Value > const _Value __numeric_traits_integer< _Value >::__min; template < typename _Value > const _Value __numeric_traits_integer< _Value >::__max; template < typename _Value > const bool __numeric_traits_integer< _Value >::__is_signed; template < typename _Value > const int __numeric_traits_integer< _Value >::__digits; template <> struct __is_integer_nonstrict< __int128 > { enum { __value = 1 }; typedef std::__true_type __type; enum { __width }; }; template struct __is_integer_nonstrict< unsigned __int128 >; ; template < typename _Tp > using __int_traits = __numeric_traits_integer< _Tp >; template < typename _Value > struct __numeric_traits_floating { static const int __max_digits10 = ((std::__are_same< int, float >::__value ? 4 : std::__are_same< int, double >::__value ? 3 : 4)); static const bool __is_signed; static const int __digits10 = (std::__are_same< int, float >::__value ? 6 : std::__are_same< int, double >::__value ? 5 : 8); static const int __max_exponent10 = (std::__are_same< int, float >::__value ? 8 : std::__are_same< int, double >::__value ? 308 : 2); }; template < typename _Value > const int __numeric_traits_floating< _Value >::__max_digits10; template < typename _Value > const bool __numeric_traits_floating< _Value >::__is_signed; template < typename _Value > const int __numeric_traits_floating< _Value >::__digits10; template < typename _Value > const int __numeric_traits_floating< _Value >::__max_exponent10; template < typename _Value > struct __numeric_traits : __numeric_traits_integer< int > {}; template <> struct __numeric_traits< float > : __numeric_traits_floating< float > {}; template <> struct __numeric_traits< double > : __numeric_traits_floating< double > {}; template <> struct __numeric_traits< long double > : __numeric_traits_floating< long > {}; } namespace std __attribute__(()) { template < typename _Tp > struct tuple_size; template < typename _Tp, typename _Up = remove_cv< _Tp >, size_t = tuple_size< _Tp >::value > using __enable_if_has_tuple_size = _Tp; template < typename _Tp > struct tuple_size< const __enable_if_has_tuple_size< _Tp > >; template < typename _Tp > struct tuple_size< volatile __enable_if_has_tuple_size< _Tp > >; template < typename _Tp > struct tuple_size< __enable_if_has_tuple_size< _Tp > >; template < typename _Tp > size_t tuple_size_v = tuple_size< _Tp >::value; template < typename _Tp > struct tuple_element; template < size_t, typename _Tp > using __tuple_element_t = tuple_element< _Tp >; template < typename _Tp > struct tuple_element< const _Tp >; template < typename _Tp > struct tuple_element< volatile _Tp >; template < typename _Tp > struct tuple_element< const volatile _Tp >; void __find_uniq_type_in_pack(); template < size_t, typename _Tp > using tuple_element_t = tuple_element< _Tp >; template < size_t... > struct _Index_tuple; template < int > struct _Build_index_tuple; ; template < typename _Tp > struct integer_sequence; ; template < typename _Tp, _Tp _Num > using make_integer_sequence = integer_sequence< _Tp, __integer_pack(_Num)... >; template < size_t... _Idx > using index_sequence = integer_sequence< size_t >; template < size_t _Num > using make_index_sequence = make_integer_sequence< size_t, _Num >; struct in_place_t; ; template < typename > struct in_place_type_t; ; template < typename _Tp > constexpr in_place_type_t< _Tp > in_place_type; struct in_place_index_t; ; template < size_t > constexpr in_place_index_t in_place_index; template < typename > bool __is_in_place_type_v; template < typename _Tp > bool __is_in_place_type_v< in_place_type_t< _Tp > >; template < typename _Tp > using __is_in_place_type = bool_constant< __is_in_place_type_v<> >; template < int, typename... > struct _Nth_type; ; template < typename _Tp0, typename... _Rest > struct _Nth_type< 0, _Tp0, _Rest... >; ; template < typename _Tp0, typename _Tp1, typename... _Rest > struct _Nth_type< 1, _Tp0, _Tp1, _Rest... >; ; template < typename _Tp0, typename _Tp1, typename _Tp2, typename... _Rest > struct _Nth_type< 2, _Tp0, _Tp1, _Tp2, _Rest... >; ; template < size_t _Np, typename _Tp0, typename _Tp1, typename _Tp2, typename... _Rest > struct _Nth_type< _Np, _Tp0, _Tp1, _Tp2, _Rest... >; ; } namespace std __attribute__(()) { struct piecewise_construct_t { piecewise_construct_t() = default; } piecewise_construct = piecewise_construct_t(); template < typename... > class tuple; template < int... > struct _Index_tuple__pair_base; ; template < typename _T1, typename _T2 > struct pair { int first; int second; template < typename... _Args1, typename... _Args2 > pair(); swap() noexcept(__and_<>::value); template < typename... > pair(); explicit(__not_< __and_< __is_implicitly_default_constructible< _T1 >, __is_implicitly_default_constructible< _T2 > > >()) pair_S_constructible(); _S_nothrow_constructible(); _S_nothrow_assignable(); operator=(pair &); operator=(pair &&); template < typename _U1, typename _U2 > void operator=(const pair< _U1, _U2 > &); template < typename _U1, typename _U2 > void operator=(pair< _U1, _U2 > &&); }; template < typename _T1, typename _T2 > void operator==(pair< _T1, _T2 >, pair< _T1, _T2 >); template < typename _T1, typename _T2 > void operator>(pair< _T1, _T2 >, pair< _T1, _T2 >); template < typename _T1, typename _T2 > void swap(); template < typename _T1, typename _T2 > void swap(); template < typename _T1, typename _T2 > pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair; template < typename _T1, typename _T2 > struct __is_tuple_like_impl< pair< _T1, _T2 > > : true_type {}; template < typename _Tp1, typename _Tp2 > constexpr size_t tuple_size_v< pair< _Tp1, _Tp2 > > = 2; template < typename > bool __is_pair; template < typename _Tp, typename _Up > bool __is_pair< pair< _Tp, _Up > >; template < size_t > struct __pair_get; template <> struct __pair_get< 0 >; ; template <> struct __pair_get< 1 >; ; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; template < typename _Tp, typename _Up > void get() noexcept; } struct _Safe_iterator; struct _Iter_less_iter; void __iter_comp_val(); template < typename _Compare > struct _Iter_comp_iter; ; template < typename _Compare > void __iter_comp_iter(); template < typename _Compare > struct _Iter_comp_val { _Iter_comp_val(); _Iter_comp_val(_Iter_comp_iter< int > &&); template < typename _Iterator, typename _Value > void operator()(); }; template < typename _Compare > void __iter_comp_val(); template < typename _Compare > void __iter_comp_val(); template < typename _Compare > struct _Val_comp_iter { int _M_comp; _Val_comp_iter() {} }; template < typename _Iterator > __iter_comp_iter() { 0; } template < typename _Predicate > struct _Iter_pred { _Iter_pred() {} template < typename _Iterator > operator()(_Iterator __it) { return bool(); } }; template < typename _Predicate > __pred_iter(void) { _Predicate __pred; _Iter_pred(stdmove(__pred)); } template < typename _Compare, typename _Value > struct _Iter_comp_to_val { _Iter_comp_to_val() {} template < typename _Iterator > operator()(_Iterator __it) { return bool(); } }; template < typename _Predicate > _Iter_pred< int > __negate___pred; __negate(void) { 0; } const int __memcmp___num = 0; namespace std __attribute__(()) { template < typename _Tp, typename _Up > __memcmp() { std: } template < typename _ForwardIterator1, typename _ForwardIterator2 > iter_swap() {} template < typename _ForwardIterator1, typename _ForwardIterator2 > swap_ranges() {} template < typename _Tp > min(void) { const int &__a; return __a; } template < typename _Tp > max() {} template < typename _Tp, typename _Compare > min() {} template < typename _Tp, typename _Compare > max() {} template < typename _Iterator > __niter_base() noexcept {} template < int, typename _Category > struct __copy_move {}; template < typename _Category > struct __copy_move< true, _Category > {}; template <> struct __copy_move< false, int > {}; template <> struct __copy_move< true, int > {}; template < bool _IsMove > struct __copy_move< _IsMove, int > {}; struct _Deque_iterator; template < typename > struct char_traits; template < typename _II, typename _OI > void copy(); template < typename _II, typename _OI > void move(); template < int, typename > struct __copy_move_backward { template < typename _BI1, typename _BI2 > void __copy_move_b(); }; template < typename _Category > struct __copy_move_backward< true, _Category > { template < typename _BI1, typename _BI2 > void __copy_move_b(); }; template <> struct __copy_move_backward< false, int > { template < typename _BI1, typename _BI2 > void __copy_move_b(); }; template <> struct __copy_move_backward< true, int > { template < typename _BI1, typename _BI2 > void __copy_move_b(); }; template < bool _IsMove > struct __copy_move_backward< _IsMove, int > { template < typename _Tp > void __copy_move_b(); }; template < bool, typename _BI1, typename _BI2 > void __copy_move_backward_a2(); template < bool, typename _BI1, typename _BI2 > void __copy_move_backward_a1(); template < bool, typename, typename, typename, typename _OI > void __copy_move_backward_a1(); template < bool, typename _ITp, typename _IRef, typename _IPtr, typename _OTp > void __copy_move_backward_a1(); template < bool, typename _II, typename > void __copy_move_backward_a1(); template < bool, typename _II, typename _OI > void __copy_move_backward_a(); template < bool, typename, typename, typename > void __copy_move_backward_a(); template < typename, typename _VTp > void __fill_a1(); template < typename _FIte, typename _Tp > void __fill_a(); template < typename, typename, typename, typename _Tp > void __fill_a(); template < typename _ForwardIterator, typename _Tp > void fill(); void __size_to_integer(); template < typename _OutputIterator, typename _Size, typename _Tp > __gnu_cxx::__enable_if< __is_scalar< _Tp >::__value, _OutputIterator > __fill_n_a1; template < typename, typename _Seqtypename, typename > void __fill_n_a(); template < typename _OutputIterator, typename _Size, typename _Tp > void __fill_n_a(); template < typename _OutputIterator, typename _Size, typename _Tp > void __fill_n_a(_OutputIterator, _Size, input_iterator_tag); template < typename _OutputIterator, typename _Size, typename _Tp > void __fill_n_a(_OutputIterator, _Size, random_access_iterator_tag); template < typename _OI, typename _Size, typename _Tp > void fill_n(); template < int > struct __equal { template < typename _II1, typename _II2 > void equal(); }; template <> struct __equal< true > { template < typename _RAI > void __cnd2(); }; template < typename _II1, typename, typename _Compare > void __lexicographical_compare_impl(); template < int _BoolType > struct __lexicographical_compare { template < typename _II1, typename _II2 > void __lc(); template < typename _II1, typename _II2 > void __3way(); }; template <> struct __lexicographical_compare< true > { template < typename _Tp, typename _Up > void __lc(); template < typename _Tp, typename _Up > void __3way(); }; template < typename _II1, typename _II2 > void __lexicographical_compare_aux1(); template < typename, typename, typename, typename _Tp2 > void __lexicographical_compare_aux1(); template < typename _Tp1, typename, typename, typename > void __lexicographical_compare_aux1(); template < typename, typename _Ref1, typename _Ptr1, typename, typename _Ref2, typename _Ptr2 > void __lexicographical_compare_aux1(); template < typename _II1, typename _II2 > void __lexicographical_compare_aux(); template < typename, typename, typename, typename _II2 > void __lexicographical_compare_aux(); template < typename, typename, typename, typename > void __lexicographical_compare_aux(); template < typename, typename _Seq1, typename _Cat1, typename, typename _Seq2, typename _Cat2 > void __lexicographical_compare_aux(); template < typename _ForwardIterator, typename _Tp, typename _Compare > void __lower_bound(_ForwardIterator, _ForwardIterator, _Compare); template < typename _ForwardIterator, typename _Tp > void lower_bound(_ForwardIterator, _ForwardIterator); void __lg(); template < typename _II1, typename _II2 > void equal(); template < typename _IIter1, typename _IIter2, typename _BinaryPredicate > void equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); template < typename _II1, typename _II2 > void __equal4(); template < typename _II1, typename _II2, typename _BinaryPredicate > void __equal4(_II1, _II1, _II2, _II2, _BinaryPredicate); template < typename _II1, typename _II2 > void equal(); template < typename _IIter1, typename _IIter2, typename _BinaryPredicate > void equal(_IIter1, _IIter1, _IIter2, _IIter2, _BinaryPredicate); template < typename _II1, typename _II2 > void lexicographical_compare(); template < typename _II1, typename _II2, typename _Compare > void lexicographical_compare(_II1, _II1, _II2, _II2, _Compare); template < typename _Iter > concept __is_byte_iter = contiguous_iterator< _Iter > && __is_memcmp_ordered< iter_value_t< _Iter > >::__value; template < typename _Tp > void __min_cmp(); template < typename _InputIter1, typename _InputIter2, typename _Comp > void lexicographical_compare_three_way(_InputIter1, _InputIter2, _Comp); template < typename _InputIter1, typename _InputIter2 > void lexicographical_compare_three_way(); template < typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate > void __mismatch(_InputIterator1, _InputIterator1, _InputIterator2, _BinaryPredicate); template < typename _InputIterator1, typename _InputIterator2 > void mismatch(_InputIterator1, _InputIterator1, _InputIterator2); template < typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate > void mismatch(_InputIterator1, _InputIterator1, _InputIterator2, _BinaryPredicate); template < typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate > void __mismatch(_InputIterator1, _InputIterator1, _BinaryPredicate); template < typename _InputIterator1, typename _InputIterator2 > void mismatch(void); template < typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate > void mismatch(void); template < typename _InputIterator > void __find_if(); template < typename _RandomAccessIterator, typename _Predicate > void __find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate); template < typename _Iterator, typename _Predicate > void __find_if(_Iterator, _Iterator, _Predicate); template < typename _InputIterator, typename _Predicate > iterator_traits< _InputIterator > __count_if; template < typename _ForwardIterator, typename _Predicate > void __remove_if(_ForwardIterator, _ForwardIterator, _Predicate); template <> bool __is_permutation; template < typename _ForwardIterator1, typename _ForwardIterator2 > void is_permutation(void); struct unary_function {}((__deprecated__)); template < typename, typename > struct binary_function {} __attribute__(()); template < typename = void > struct plus; template < typename > struct plus; ; template < typename > struct minus; template < typename > struct multiplies; template < typename > struct divides; template < typename > struct modulus; template < typename > struct negate; template <> struct plus<> { template < typename _Tp, typename _Up > void operator()(); }; template <> struct minus< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct multiplies< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct divides< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct modulus< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct negate< void > { template < typename _Tp > void operator()(); }; template < typename = void > struct less; template < typename > struct equal_to; template < typename > struct not_equal_to; template < typename > struct greater; template < typename > struct less; template < typename > struct greater_equal; template < typename > struct less_equal; template < typename _Tp > struct greater< _Tp * >; template < typename _Tp > struct less< _Tp * >; template < typename _Tp > struct greater_equal< _Tp * >; template < typename _Tp > struct less_equal< _Tp * >; template <> struct equal_to< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct not_equal_to< void > { template < typename _Tp, typename _Up > void operator()(); }; template <> struct greater< void > { template < typename _Tp, typename _Up > auto operator()(); template < typename _Tp, typename _Up > void operator()(); template < typename _Tp, typename _Up > void _S_cmp(); template < typename _Tp, typename _Up > bool _S_cmp(); template < typename, typename > struct __not_overloaded2 {}; template < typename _Up > struct __not_overloaded2< _Up, __void_t<> > {}; template < typename, typename = void > struct __not_overloaded; template < typename _Up > struct __not_overloaded< _Up, __void_t<> >; template < typename _Tp, typename _Up > using __ptr_cmp = __and_<>; }; template <> struct less<> { template < typename _Tp, typename _Up > void operator()(); template < typename _Tp, typename _Up > void operator()(_Up *); template < typename _Tp, typename _Up > void _S_cmp(); template < typename _Tp, typename _Up > void _S_cmp(true_type); template < typename, typename, typename > struct __not_overloaded2 {}; template < typename _Tp, typename _Up > struct __not_overloaded2< _Tp, _Up, __void_t<> > {}; template < typename, typename, typename = void > struct __not_overloaded; template < typename _Tp, typename _Up > struct __not_overloaded< _Tp, _Up, __void_t<> >; template < typename _Tp, typename _Up > using __ptr_cmp = __and_<>; }; template <> struct greater_equal< void > { template < typename _Tp, typename _Up > void operator()(); template < typename _Tp > void operator()(); template < typename _Tp, typename _Up > void _S_cmp(); template < typename _Tp, typename _Up > void _S_cmp(_Tp &&, _Up &&, true_type); template < typename, typename, typename > struct __not_overloaded2 {}; template < typename _Tp, typename _Up > struct __not_overloaded2< _Tp, _Up, __void_t< decltype(declval< _Tp >().operator>=) > > {}; template < typename, typename, typename = void > struct __not_overloaded; template < typename _Tp, typename _Up > struct __not_overloaded< _Tp, _Up, __void_t<> >; template < typename _Tp, typename _Up > using __ptr_cmp = __and_<>; }; template <> struct less_equal< void > { template < typename _Tp, typename _Up > void operator()(); template < typename _Tp, typename _Up > void operator()(_Tp *, _Up *); template < typename _Tp, typename _Up > void _S_cmp(); template < typename _Tp, typename _Up > void _S_cmp(_Tp &&, _Up &&, true_type); template < typename, typename, typename > struct __not_overloaded2 {}; template < typename _Tp, typename _Up > struct __not_overloaded2< _Tp, _Up, __void_t< decltype(std::declval< _Tp >().operator<=) > > : false_type {}; template < typename, typename, typename = void > struct __not_overloaded; template < typename _Tp, typename _Up > struct __not_overloaded< _Tp, _Up, __void_t<> >; template < typename _Tp, typename _Up > using __ptr_cmp = __and_<>; }; template < typename = void > struct logical_and; template < typename > struct logical_and; template < typename > struct logical_or; template < typename > struct logical_not; template <> struct logical_and<> { template < typename _Tp, typename _Up > void operator()(); }; template <> struct logical_or< void > { template < typename _Tp, typename _Up > void operator()(_Tp &&, _Up &&); }; template <> struct logical_not< void > { template < typename _Tp > void operator()(_Tp &&); }; template < typename > struct bit_and; template < typename > struct bit_or; template < typename > struct bit_xor; template < typename > struct bit_not; template <> struct bit_and< void > { template < typename _Tp, typename _Up > void operator()(_Tp &&, _Up &&); }; template <> struct bit_or< void > { template < typename _Tp, typename _Up > void operator()(_Tp &&, _Up &&); }; template <> struct bit_xor< void > { template < typename _Tp, typename _Up > void operator()(_Tp &&, _Up &&); }; template <> struct bit_not< void > { template < typename _Tp > void operator()(_Tp &&); }; template < typename _Predicate > struct unary_negate { int _M_pred; operator()(_Predicate::argument_type &__x); }; template < typename _Predicate > void not1(); template < typename _Predicate > struct binary_negate : binary_function< typename _Predicate::first_argument_type, typename _Predicate::second_argument_type > { _Predicate &_M_pred___y; }; template < typename _Predicate > binary_negate< _Predicate > not2; struct pointer_to_unary_function __attribute__(()); template < typename, typename _Result > struct pointer_to_binary_function __attribute__(()); template < typename _Arg1_Arg2, typename _Result > void ptr_fun(_Result); struct _Identity {} _Select1st; struct _Select2nd; template < typename > struct mem_fun_t {} __attribute__(()); template < typename > struct const_mem_fun_t {} __attribute__(()); template < typename > struct mem_fun_ref_t {} __attribute__(()); template < typename, typename > struct const_mem_fun_ref_t {} __attribute__(()); template < typename, typename, typename > struct mem_fun1_t {} __attribute__(()); template < typename, typename > struct const_mem_fun1_t {} __attribute__(()); template < typename _Ret, typename _Tp, typename _Arg > struct mem_fun1_ref_t { operator()(_Tp &__x); } __attribute__(()); template < typename _Ret, typename _Tp, typename _Arg > struct const_mem_fun1_ref_t { operator()(_Tp &__r, _Arg __x); (_Tp::*_M_f); } __attribute__(()); template < typename _Ret, typename _Tp > mem_fun(_Ret()) { return mem_fun_t< _Tp >(); } template < typename _Ret, typename _Tp > mem_fun(_Ret(_Tp::*__f)() const) { return const_mem_fun_t< _Tp >(); } template < typename _Ret, typename _Tp > mem_fun_ref(_Ret()) { return mem_fun_ref_t< _Tp >(); } template < typename _Ret, typename _Tp > mem_fun_ref(_Ret(_Tp::*__f)() const) { return const_mem_fun_ref_t< int, _Tp >(); } template < typename _Ret, typename _Tp, typename _Arg > mem_fun(_Ret()) { return mem_fun1_t< int, int, _Arg >(); } template < typename _Ret, typename _Tp, typename _Arg > mem_fun(_Ret(_Tp::*__f)() const) { return const_mem_fun1_t< int, _Arg >(); } template < typename _Ret, typename _Tp, typename _Arg > mem_fun_ref(_Ret(_Tp::*__f)()) { return mem_fun1_ref_t< int, int, _Arg >(); } template < typename _Ret, typename _Tp, typename _Arg > mem_fun_ref(_Ret(_Tp::*__f)() const) { return const_mem_fun1_ref_t< int, int, _Arg >(); } template < typename, typename, typename = __void_t<> > struct __has_is_transparent; template < typename _Func, typename _SfinaeType > struct __has_is_transparent< _Func, _SfinaeType, __void_t<> > { typedef void type; }; template < typename _Func, typename _SfinaeType > using __has_is_transparent_t = __has_is_transparent< _Func, _SfinaeType >::type; } template < typename _Operation > struct binder1st { _Operation::value; binder1st(void) {} operator()(const _Operation); operator()(_Operation::second_argument_type__x) const; } __attribute__(()); template < typename _Operation, typename _Tp > bind1st(void) {} template < typename _Operation > struct binder2nd { binder2nd(void) {} operator()(const _Operation::first_argument_type__x) {} operator()(_Operation &) const { 0; (0); (0); } } __attribute__((__deprecated__(""))); template < typename _Operation, typename _Tp > bind2nd(void) {} template < typename _Tp > struct __new_allocator { typedef long size_type; __new_allocator() {} [[]] _Tp *allocate(size_type __n, void * = static_cast< void >(0)) { if ((__n > _M_max_size(), false)) { std::align_val_t __al = std::align_val_t(); (operator new(__n * sizeof(_Tp), __al)); } } deallocate(_Tp *__p, size_type()) { delete ((__p) * sizeof(_Tp), std::align_val_t()); } template < typename _Up > friend operator==(__new_allocator, __new_allocator< _Up >); _M_max_size() const noexcept { return std::size_t() / sizeof(_Tp); } }; template < typename _Tp > using __allocator_base = __new_allocator< _Tp >; int construct___p = 0; namespace std __attribute__(()) { template < typename > class allocator; template <> struct allocator< void > { using is_always_equal = true_type; }; template < typename _Tp > struct allocator : __allocator_base< int > { typedef int value_type; using is_always_equal = true_type; allocator() noexcept {} allocator(allocator &) noexcept {} void allocate(void) { (0); if (0) ((0)); } deallocate(_Tp *, size_t); friend operator==(allocator, allocator); }; template < typename _T1, typename _T2 > operator==(const allocator< _T1 > &, const allocator< _T2 > &) { true; } template < typename _Tp > struct allocator< const _Tp >; ; template < typename _Tp > struct allocator< volatile _Tp >; ; struct __alloc_swap; ; template < int > struct __alloc_neq; template <> struct __alloc_neq< false >; struct __shrink_to_fit_aux; struct __allocator_traits_base { template < typename _Tp, typename _Up, typename = void > struct __rebind; template < typename _Tp, typename _Up > struct __rebind< _Tp, _Up, __void_t<> > { using type = _Tp::template rebind<>::other; }; template < typename _Tp > using __pointer = _Tp::pointer; template < typename _Tp > using __c_pointer = _Tp::const_pointer; template < typename _Tp > using __cv_pointer = _Tp::const_void_pointer; template < typename _Tp > using __pocca = _Tp::propagate_on_container_copy_assignment; template < typename _Tp > using __pocma = _Tp::propagate_on_container_move_assignment; template < typename _Tp > using __pocs = _Tp::propagate_on_container_swap; template < typename _Tp > using __equal = _Tp::is_always_equal; }; template < typename _Alloc, typename _Up > using __alloc_rebind = __allocator_traits_base::__rebind< _Alloc, _Up >; template < typename _Alloc > struct allocator_traits : __allocator_traits_base { typedef _Alloc value_type; using pointer = __detected_or_t< value_type, __pointer, _Alloc >; template < template < typename > class, typename = void > struct _Ptr; template < template < typename > class _Func > struct _Ptr< _Func, __void_t<> >; template < typename, typename _PtrT, typename = void > struct _Diff { pointer_traits< _PtrT >::difference_type; }; template < typename _A2, typename _PtrT > struct _Diff< _A2, _PtrT, __void_t<> > { using type = _A2; }; template < typename, typename _DiffT, typename = void > struct _Size : make_unsigned< _DiffT > {}; template < typename _A2, typename _DiffT > struct _Size< _A2, _DiffT, __void_t<> > { using type = _A2; }; using const_void_pointer = _Ptr< __cv_pointer >; using difference_type = _Diff< _Alloc, pointer >::type; using size_type = _Size< _Alloc, difference_type >; using propagate_on_container_copy_assignment = __detected_or_t< false_type, __pocca, _Alloc >; using propagate_on_container_move_assignment = __detected_or_t< false_type, __pocma, _Alloc >; using is_always_equal = __detected_or_t< typename is_empty< _Alloc >::type, __equal, _Alloc >; template < typename _Tp > using rebind_alloc = __alloc_rebind< _Alloc, _Tp >; template < typename _Tp > using rebind_traits = allocator_traits< rebind_alloc< _Tp > >; template < typename _Alloc2 > void _S_allocate(size_type, const_void_pointer, int); template < typename _Alloc2 > void _S_allocate(size_type); template < typename... > struct __construct_helper { template < typename, typename = decltype((0)) > void __test(); }; template < typename... _Args > using __has_construct = __construct_helper<>; template < typename _Tp, typename... _Args > void _S_construct(_Args...); template < typename _Tp, typename... _Args > void _S_construct(_Alloc...); template < typename _Alloc2, typename _Tp > void _S_destroy(_Tp *, int); template < typename _Alloc2, typename _Tp > void _S_destroy(_Alloc2, _Tp *); template < typename _Alloc2 > void _S_max_size(_Alloc2 &, int); template < typename _Alloc2 > void _S_max_size(_Alloc2); template < typename _Alloc2 > void _S_select(_Alloc2 &, int); template < typename _Alloc2 > void _S_select(_Alloc2 &); allocate(size_type); allocate(_Alloc &, size_type, const_void_pointer); deallocate(_Alloc &, pointer, size_type); _Alloc &construct___a; template < typename _Tp, typename... _Args > construct(_Args &&...__args) noexcept { _S_construct; } template < typename _Tp > destroy(void) {} max_size(_Alloc &); select_on_container_copy_construction(const _Alloc &); }; template < typename _Tp > struct allocator_traits< allocator< _Tp > > { using allocator_type = allocator< _Tp >; using value_type = _Tp; using pointer = _Tp *; using const_pointer = const _Tp *; using const_void_pointer = void *; using difference_type = ptrdiff_t; using size_type = size_t; template < typename _Up > using rebind_alloc = allocator< _Up >; template < typename _Up > using rebind_traits = allocator_traits< allocator< _Up > >; [[]] allocate(allocator_type &__a) { allocate; } allocate(const_void_pointer) {} deallocate(allocator_type, size_type __n) { allocator_traits: pointer __p = 0; __adeallocate(__p); } template < typename _Up, typename... _Args > construct(allocator_type, _Args... __args) { _Up *__p = 0; stdconstruct_at(stdforward(__args)...); } template < typename _Up > destroy(_Up *) {} max_size(allocator_type &()) { (1) / sizeof(value_type); } select_on_container_copy_construction(allocator_type) {} }; template <> struct allocator_traits< allocator< void > > { using allocator_type = allocator< void >; using size_type = size_t; template < typename _Up, typename... _Args > void construct(allocator_type, _Up *...); template < typename _Up > destroy(void) {} std::allocator_traits< struct std::allocator< void > >::allocator_type &select_on_container_copy_construction___rhs; void select_on_container_copy_construction(void) { select_on_container_copy_construction___rhs; } }; template < typename _Alloc > __alloc_on_copy(_Alloc &) { typedef allocator_traits< _Alloc > __traits; typename __traits::propagate_on_container_copy_assignment __pocca; } template < typename _Alloc > __alloc_on_copy(void) { typedef allocator_traits< int > __traits; } template < typename _Alloc > __alloc_on_move(void) { typedef allocator_traits< _Alloc > __traits; typedef typename __traits::propagate_on_container_move_assignment __pocma; } template < typename _Alloc > __alloc_on_swap(void) { typedef allocator_traits< _Alloc > __traits; typename __traits::propagate_on_container_swap __pocs; } template < typename _Alloc, typename = __remove_cvref_t< typename _Alloc::value_type >, typename = void > struct __is_alloc_insertable_impl; template < typename _Alloc, typename _ValueT > struct __is_alloc_insertable_impl< _Alloc, _ValueT, __void_t<> >; template < typename _Alloc > struct __is_copy_insertable; template < typename _Tp > struct __is_copy_insertable< allocator< _Tp > >; template < typename _Alloc > struct __is_move_insertable; template < typename _Tp > struct __is_move_insertable< allocator< _Tp > > {}; template < typename = void > struct __is_allocator {}; template <> struct __is_allocator< __void_t<> > : true_type {}; template < typename _Alloc > using _RequireAllocator = enable_if< __is_allocator<>::value, _Alloc >::type; template < typename _Alloc > using _RequireNotAllocator = enable_if< !__is_allocator<>::value, _Alloc >::type; template < typename _Alloc > concept __allocator_like = requires(_Alloc & __a) { __a.deallocate; }; template < typename _ForwardIterator, typename _Allocator > _Destroy(void) {} template < typename _ForwardIterator, typename _Tp > _Destroy(allocator< _Tp > &) {} } namespace __gnu_cxx __attribute__((__visibility__(""))) { template < typename _Alloc > struct __alloc_traits : std::allocator_traits< _Alloc > { typedef std::allocator_traits< _Alloc > _Base_type; typedef _Alloc::value_type value_type; typedef _Base_type::pointer pointer; typedef value_type &reference; typedef const value_type &const_reference; _Base_type::construct; template < typename _Ptr > using __is_custom_pointer = std::__and_<>; template < typename _Ptr, typename... _Args > construct(_Args &&...__args) noexcept(noexcept(construct)) { int __p; _Alloc &__a; _Base_type: construct(__a, std::__to_address, std::forward(__args)...); } template < typename _Ptr > destroy(_Ptr) { (0, 0); } void _S_select_on_copy(const _Alloc &) { 0; (0); } _S_propagate_on_swap() { _Base_type::propagate_on_container_swap::value; } _S_always_equal() { _Base_type::is_always_equal::value; } template < typename _Tp > struct rebind { typedef _Base_type::template rebind_alloc< _Tp > other; }; }; template < typename _Tp > struct __aligned_membuf { int _M_t; }; template < typename > struct __aligned_buffer {}; } namespace std __attribute__((__visibility__)) { struct _Fwd_list_node_base { _Fwd_list_node_base *_M_next = nullptr; _M_transfer_after(_Fwd_list_node_base) noexcept; }; template < typename _Tp > struct _Fwd_list_node { __gnu_cxx::__aligned_buffer< int > _M_storage; _M_valptr() const { _M_storage; } }; template < typename _Tp > struct _Fwd_list_iterator { typedef _Fwd_list_iterator< _Tp > _Self; typedef _Fwd_list_node< _Tp > _Node; typedef _Tp *pointer; typedef _Tp &reference; _Fwd_list_iterator() noexcept {} _Fwd_list_iterator(_Fwd_list_node_base *__n) noexcept : _M_node(__n) {} operator*() { *static_cast< _Node >(this->_M_node)->_M_valptr; } operator->() { static_cast< _Node >(this->_M_node)->_M_valptr; } operator++() {} operator++(int) noexcept {} friend operator==(_Self &, _Self &) { 0; (0); (0); } _M_next() const noexcept { if (&_M_node) (_M_node._M_next); } _Fwd_list_node_base _M_node; }; template < typename _Tp > struct _Fwd_list_const_iterator { typedef _Fwd_list_const_iterator< _Tp > _Self; typedef const _Fwd_list_node< _Tp > _Node; typedef _Fwd_list_iterator< _Tp > iterator; typedef _Tp *pointer; typedef const _Tp &reference; _Fwd_list_const_iterator() noexcept {} _Fwd_list_const_iterator(const *__n) noexcept : _M_node(__n) {} _Fwd_list_const_iterator(const iterator &__iter) noexcept {} operator*() { *static_cast< _Node >(this->_M_node)->_M_valptr; } operator->() { static_cast< _Node >(this->_M_node)->_M_valptr; } operator++() {} operator++(int) noexcept { void __tmp(); } friend operator==(_Self &, _Self &) noexcept { 0; (0); (0); } _M_next() const noexcept { if (this->_M_node) (_M_node->_M_next); } const _Fwd_list_node_base *_M_node; }; template < typename _Alloc > struct _Fwd_list_base { typedef __alloc_rebind< int, _Fwd_list_node< int > > _Node_alloc_type; typedef __gnu_cxx::__alloc_traits< _Node_alloc_type > _Node_alloc_traits; struct _Fwd_list_impl { _Fwd_list_node_base _M_head; _Fwd_list_impl() {} _Fwd_list_impl(_Fwd_list_impl &&) {} _Fwd_list_impl(_Node_alloc_type &&) {} } _M_impl; typedef _Fwd_list_const_iterator< int > const_iterator; typedef _Fwd_list_node< int > _Node; _M_get_Node_allocator() { this->_M_impl; } _M_get_Node_allocator() const noexcept { this->_M_impl; } _Fwd_list_base(_Node_alloc_type &&) {} _Fwd_list_base(true_type) { _Fwd_list_base< int > &&__lst; } _Fwd_list_base() { _M_erase_after(&_M_impl._M_head, nullptr); } _M_get_node() { auto __ptr = (_M_get_Node_allocator, 1); } template < typename... _Args > _M_create_node(_Args &&...__args) { void __node(); { _Node_alloc_traits: construct(_M_get_Node_allocator, (__args)...); } } template < typename... > void _M_put_node(_Node *); _M_erase_after(_Fwd_list_node_base **); }; template < typename _Tp, typename _Alloc = allocator< int > > struct forward_list : _Fwd_list_base< _Alloc > { static_assert(is_same< int >::value, ""); static_assert(is_same< int >::value, ""); typedef _Fwd_list_base< _Alloc > _Base; typedef _Base::_Node _Node; _Base::_Node_alloc_type _Node_alloc_type; typedef _Base::_Node_alloc_traits _Node_alloc_traits; typedef allocator_traits< __alloc_rebind< _Alloc, int > > _Alloc_traits; typedef int value_type; typedef _Base::iterator iterator; typedef _Base::const_iterator const_iterator; template < typename _InputIterator, _RequireInputIter< _InputIterator > > void assign(_InputIterator, _InputIterator); before_begin() noexcept(this->_M_impl._M_head._M_next); begin() { const_iterator(this->_M_impl._M_head._M_next->_M_impl._M_head._M_next); } cbefore_begin() const noexcept { const_iterator(&this->_M_impl._M_head); 0; (0); } front() { _Node *__front = (this->_M_impl._M_head._M_next); } push_front(void) { int &__val; (cbefore_begin(), __val); } push_front(_Tp &&__val) { this->_M_insert_after(cbefore_begin(__val)); } pop_front() {} insert_after(void) { 0; (0); ((0)); } template < typename _Comp > void merge(forward_list &, _Comp); template < typename _Comp > void reverse() noexcept; template < typename _InputIterator > void _M_splice_after(const_iterator); template < typename _InputIterator > void _M_assign(_InputIterator, _InputIterator, true_type); template < typename _InputIterator > void _M_assign(_InputIterator, _InputIterator, false_type); }; template < typename _InputIterator, typename _ValT = iterator_traits< _InputIterator >::value_type, typename _Allocator = allocator< _ValT >, typename = _RequireAllocator< _Allocator > > forward_list(_InputIterator, _InputIterator, _Allocator) -> forward_list< _Allocator >; template < typename _Tp, typename _Alloc > void operator==(forward_list< _Alloc >, forward_list< _Alloc >); template < typename _Tp, typename _Alloc > operator>(forward_list< _Alloc > __x, const forward_list< _Tp > &) { 0; } template < typename _Tp, typename _Alloc > swap(void) {} } int rend___arr; namespace std __attribute__((__visibility__(""))) { template < typename _Container > auto begin(void)->decltype(0) { int &__cont; } template < typename _Tp, int > begin(_Tp()) noexcept {} template < typename _Tp, size_t > end(_Tp) { (0); } class valarray; template < typename > cbegin() noexcept(((0))) {} template < typename > cend(void) noexcept(((0))) { (0); } template < typename _Container > auto rbegin(int &__cont)->decltype(0) {} template < typename _Container > auto rend(int &__cont)->decltype(0) {} template < typename _Tp, int > rbegin(_Tp) { ((0)); } template < typename _Tp, int _Nm > rend(void) {} template < typename _Tp > rbegin(void) { reverse_iterator< int >(); } template < typename _Tp > rend(void) { 0; reverse_iterator< int >(); } template < typename > auto crbegin(void)->decltype((0)) { 0; 0; (0); } template < typename _Container > auto crend(void)->decltype((0)) { const int &__cont; 0; (0); __cont; } template < typename _Tp, int _Nm > size(void) noexcept {} template < typename _Container > void empty(void) noexcept(noexcept(0)) { const int &__cont; 0; } template < typename _Tp, int > empty(void) noexcept { return false; } template < typename _Tp > empty() { initializer_list< int > __il; 0; (0); (0); } template < typename _Container > void data(void) noexcept(noexcept(0)) { int &__cont; 0; } template < typename _Tp, int > data(_Tp(&__array)) noexcept { __array; } template < typename _Tp > data(void) noexcept { initializer_list< int > __il; 0; } template < typename _Container > void ssize() { const _Container &__cont; using type = make_signed_t< decltype(__cont.size()) >; } template < typename _Tp, int _Num > ssize(void) noexcept { return _Num; } } namespace std __attribute__(()) { template < typename _Tp, typename _Alloc > void operator==(forward_list< _Alloc >, forward_list< _Tp, _Alloc > &); } typedef long unsigned size_t; struct {} max_align_t; extern "C++" namespace std { template < typename > struct __byte_operand; template < typename _IntegerType > using __byte_op_t = __byte_operand< _IntegerType >; template < typename > operator<(byte, int) {} template < typename > operator>(byte, int) {} operator~(byte __b) { (char)(unsigned)__b; } template < typename _IntegerType > operator<=(byte &__b, _IntegerType) { __b; } template < typename _IntegerType > operator>=(byte &__b, _IntegerType __shift) { __b = (0); } operator|=(byte &__l, byte __r) { std: byte __trans_tmp_3; { std::byte __trans_tmp_4 = __l; std::byte __trans_tmp_5 = __r; { std::byte __l = __l; std::byte __r = __r; (byte)(char)(__l | (unsigned)__r); } } __l = __trans_tmp_3; } operator&=(byte &__l, byte __r) { std: byte __trans_tmp_6; { std::byte __trans_tmp_7 = __l; std::byte __trans_tmp_8 = __r; { std::byte __l = __l; std::byte __r = __r; (byte)(char)(__l & (unsigned)__r); } } __l = __trans_tmp_6; } operator^=(byte &__l, byte __r) { std: byte __trans_tmp_9; { std::byte __trans_tmp_10 = __l; std::byte __trans_tmp_11 = __r; { std::byte __l = __l; std::byte __r = __r; (byte)(char)(__l ^ (unsigned)__r); } } __l = __trans_tmp_9; } template < typename _IntegerType > to_integer(void) { __byte_op_t< _IntegerType > __b; return (__b); } } int __uses_allocator_construct_impl___ptr = 0; namespace std __attribute__(()) { struct __erased_type; template < typename _Alloc, typename _Tp > using __is_erased_or_convertible = __or_<>; struct allocator_arg_t { allocator_arg_t(); } allocator_arg = allocator_arg_t(); template < typename, typename, typename = __void_t<> > struct __uses_allocator_helper; template < typename _Tp, typename _Alloc > struct __uses_allocator_helper< _Tp, _Alloc, __void_t<> >; template < typename, typename > struct uses_allocator; struct __uses_alloc1 *_M_a; template < typename > struct __uses_alloc2; template < bool, typename... > struct __uses_alloc; template < typename _Tp, typename _Alloc, typename... _Args > struct __uses_alloc< true, _Tp, _Alloc, _Args... > { static_assert(__or_< is_constructible< _Args... > >::value, ""); }; template < typename _Tp, typename _Alloc, typename... _Args > struct __uses_alloc< false, _Tp, _Alloc, _Args... >; template < typename _Tp, typename _Alloc, typename... _Args > using __uses_alloc_t = __uses_alloc< uses_allocator< _Tp, _Alloc >::_Alloc, _Args... >; template < typename _Tp, typename _Alloc, typename... _Args > void __use_alloc(); template < typename... > void __use_alloc(); template < typename _Tp, typename _Alloc > bool uses_allocator_v = uses_allocator< _Tp, _Alloc >::value; template < template < typename... > class _Predicate, typename _Tp, typename _Alloc, typename... _Args > struct __is_uses_allocator_predicate : __conditional_t< uses_allocator< int, _Alloc >::value, __or_<>, _Predicate<> > {}; template < typename _Tp, typename _Alloc > struct __is_uses_allocator_constructible; template < typename _Tp, typename _Alloc, typename... _Args > bool __is_uses_allocator_constructible_v = __is_uses_allocator_constructible< _Args... >::value; template < typename _Tp, typename _Alloc, typename > struct __is_nothrow_uses_allocator_constructible; template < typename _Tp, typename _Alloc, typename... _Args > bool __is_nothrow_uses_allocator_constructible_v = __is_nothrow_uses_allocator_constructible< _Args... >::value; template < typename _Tp, typename... _Args > void __uses_allocator_construct_impl(); template < typename _Tp, typename... _Args > __uses_allocator_construct_impl(_Args && ...__args) { struct std::__uses_alloc1 __a; new (&__uses_allocator_construct_impl___ptr) int(*__astdforward(__args)...); } template < typename _Tp, typename _Alloc, typename... _Args > __uses_allocator_construct_impl(_Args && ...__args) { int *__ptr = 0; __uses_alloc2< _Alloc > __a; new ((void)__ptr) int(stdforward(__args)..., *__a); } template < typename _Tp, typename _Alloc, typename... _Args > __uses_allocator_construct(_Args && ...__args) { 0; } template < typename _Tp, __inv_unwrap< _Tp > type > __invfwd(void) { typename remove_reference< _Tp >::type &__t; return static_cast< int && >(__t); } template < typename _Fn, typename... _Args > __invoke_impl(_Args && ...__args) { _Fn &&__f; forward(__f)(stdforward(__args)...); } template < typename _MemFun, typename _Tp, typename... _Args > __invoke_impl(_Args && ...__args) { _Tp &&__t; int &&__f; (__invfwd(__t))(stdforward(__args)...); } template < typename, typename... _Args > __invoke_impl() {} template < typename _MemPtr, typename _Tp > __invoke_impl(void) { int &&__f; } template < typename _MemPtr, typename _Tp > __invoke_impl(_Tp && __t) { int &&__f; (*stdforward(__t)); } template < typename _Callable, typename... _Args > __invoke(_Args && ...__args) { int &&__fn; using __result = __invoke_result< _Args... >; std__invoke_impl(forward > stdforward(__args)...); } template < typename _Callable, typename... _Args > __invoke_r(_Args && ...__args) { _Callable &&__fn; using __result = __invoke_result< _Args... >::__invoke_type; if (is_void_v<>) std__invoke_impl(forward > (__fn), stdforward(__args)...); std__invoke_impl(std::forward > (__args)...); } } namespace std __attribute__(()) { struct memory_resource { static constexpr size_t _S_max_align = alignof(max_align_t); unsigned long allocate___bytes; void *allocate; is_equal(void) const noexcept; virtual *do_allocate(); virtual do_deallocate(); void do_is_equal() const; }; template < typename _Tp > struct polymorphic_allocator; ; template < typename _Tp1, typename _Tp2 > operator==(const polymorphic_allocator< _Tp1 > &__a, const polymorphic_allocator< _Tp2 > &__b) noexcept {} template < typename _Tp > struct allocator_traits< polymorphic_allocator< _Tp > >; ; } namespace std __attribute__(()) { template < typename _Tp, typename _Alloc, typename _Predicate > erase_if() {} template < typename _Tp, typename _Alloc, typename _Up > erase() { forward_list< int > __cont; using __elem_type = forward_list< int, int >; std: (__cont, [] {}); } template < class > struct char_traits; namespace __cxx11 { template < typename _CharT, typename = allocator< _CharT > > class basic_string; } typedef basic_string< char > string; typedef basic_string< wchar_t > wstring; typedef basic_string< char8_t > u8string; typedef basic_string< char16_t > u16string; typedef basic_string< char32_t > u32string; } typedef __float128 _Float128; typedef float _Float32; typedef double _Float64; typedef double _Float32x; typedef long _Float64x; typedef __builtin_va_list __gnuc_va_list; typedef unsigned wint_t; typedef struct {} __mbstate_t; typedef __mbstate_t mbstate_t; typedef struct _IO_FILE __FILE; typedef _IO_FILE FILE; struct __locale_struct {}; typedef __locale_struct __locale_t; typedef __locale_struct locale_t; extern "C" wchar_t wcscpy() __attribute__(()); wchar_t wcsncpy() __attribute__(()); wchar_t wcscat() __attribute__(()); wchar_t wcsncat() __attribute__(()); void wcscmp() __attribute__(()); void wcsncmp(void) __attribute__(()); void wcsncasecmp(void); void wcscasecmp_l(); void wcsncasecmp_l(); void wcscoll(); void wcsxfrm(); void wcscoll_l(); void wcsxfrm_l(wchar_t, wchar_t, size_t, locale_t); wchar_t wcsdup __attribute__(()) __attribute__(()); extern wcschr() __asm("") __attribute__(()); extern "C++" wchar_t wcschr(wchar_t *, wchar_t) __asm("") __attribute__(()); extern "C++" wchar_t wcsrchr() __asm("") __attribute__(()); extern "C++" wchar_t wcsrchr() __asm("") __attribute__(()); wchar_t wcschrnul __attribute__(()); void wcscspn(void); void wcsspn(); extern "C++" wchar_t wcspbrk() __asm("") __attribute__(()); extern "C++" wchar_t wcspbrk(void) __asm("") __attribute__(()); extern "C++" wchar_t wcsstr() __asm("") __attribute__(()); extern "C++" wchar_t wcsstr() __asm("") __attribute__(()); wchar_t wcstok() noexcept; void wcslen() noexcept __attribute__(()); extern "C++" wchar_t wcswcs() __asm("") __attribute__(()); extern "C++" wchar_t wcswcs(void) noexcept __asm("") __attribute__(()); void wcsnlen() noexcept __attribute__(()); extern "C++" wchar_t wmemchr() __asm("") __attribute__(()); extern "C++" wchar_t *wmemchr(const, wchar_t, size_t) __asm("") __attribute__(()); void wmemcmp(); wchar_t *wmemcpy(); wchar_t *wmemmove() noexcept; wchar_t *wmemset(wchar_t *, wchar_t, size_t) noexcept; wchar_t wmempcpy(); void mbsinit(const mbstate_t *); void mbrtowc(wchar_t *, const char *, size_t, mbstate_t *) noexcept; void wcrtomb(char *, wchar_t, mbstate_t) noexcept; void __mbrlen(const char *, size_t, mbstate_t *); void mbrlen(const char *, mbstate_t *); void __btowc_alias(int) __asm(""); __attribute__(()) btowc() noexcept {} void __wctob_alias(wint_t) __asm(""); wint_t wctob___wc; __attribute__(()) wctob() noexcept {} void mbrlen(const char *__restrict __s, mbstate_t *__restrict __ps) noexcept; void mbsrtowcs(wchar_t *, mbstate_t) noexcept; void wcsrtombs(char *, mbstate_t); void mbsnrtowcs(wchar_t *, size_t, mbstate_t) noexcept; void wcsnrtombs(mbstate_t *) noexcept; void wcstod(wchar_t *, wchar_t *); void wcstof(wchar_t *, wchar_t *); void wcstold(wchar_t *, wchar_t *); void wcstof32(wchar_t); void wcstof64(wchar_t *, wchar_t *); void wcstof128(wchar_t *, wchar_t *); void wcstof32x(wchar_t *, wchar_t *); void wcstof64x(wchar_t *, wchar_t *) noexcept; void wcstol(wchar_t *, wchar_t *, int); void wcstoul(wchar_t *, wchar_t *, int); void wcstoll(wchar_t *, wchar_t *, int); void wcstoull(wchar_t *, int); void wcstoq(wchar_t, int); void wcstouq(const *, int) noexcept; void wcstol_l(wchar_t *, locale_t); void wcstoul_l(int, locale_t); void wcstoll_l(int, locale_t); void wcstoull_l(wchar_t *, int, locale_t); void wcstod_l(wchar_t **, locale_t); void wcstof_l(wchar_t *, wchar_t *, locale_t) noexcept; void wcstold_l(wchar_t *, locale_t); void wcstof32_l(wchar_t *, locale_t); void wcstof64_l(wchar_t *, locale_t); void wcstof128_l(const *, locale_t) noexcept; void wcstof32x_l(wchar_t *, locale_t) noexcept; void wcstof64x_l(wchar_t *, locale_t) noexcept; wchar_t wcpcpy(wchar_t *, const *) noexcept; wchar_t wcpncpy(size_t); void fwide(void) noexcept; int fwprintf; int wprintf; void swprintf(wchar_t *, size_t, wchar_t *) noexcept; void vfwprintf(__FILE, __gnuc_va_list); void vwprintf(wchar_t *, __gnuc_va_list); void vswprintf(wchar_t *, size_t, const wchar_t *, __gnuc_va_list); void fwscanf(__FILE, wchar_t *); void swscanf(wchar_t *, wchar_t) noexcept; void wscanf(wchar_t *) __asm__("" ""); void vfwscanf(__FILE **, __gnuc_va_list); void vwscanf(wchar_t *, __gnuc_va_list); void vswscanf(const __gnuc_va_list); void ungetwc(__FILE); wchar_t fgetws_unlocked(wchar_t *, __FILE); void fputws_unlocked(const, __FILE *__restrict); void wcsftime(void) noexcept; void wcsftime_l(locale_t) noexcept; extern "C++" namespace std __attribute__((__visibility__())) { using ::vfwprintf; using ::vfwscanf; using ::vswprintf; using ::vswscanf; using ::vwprintf; using ::vwscanf; using ::wcrtomb; using ::wcscat; using ::wcschr; using ::wcscmp; using ::wcscoll; using ::wcscpy; using ::wcscspn; using ::wcsftime; using ::wcslen; using ::wcsncat; using ::wcsncmp; using ::wcsncpy; using ::wcspbrk; using ::wcsrchr; using ::wcsrtombs; using ::wcsspn; using ::wcsstr; using ::wcstod; using ::wcstof; using ::wcstok; using ::wcstol; using ::wcstoul; using ::wcsxfrm; using ::wctob; using ::wmemchr; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; using ::wmemset; using ::wprintf; using ::wscanf; } namespace std __attribute__((__visibility__(""))) { typedef long streamoff; typedef long streamsize; template < typename _StateT > struct fpos; ; template < typename _StateT > operator==(fpos< _StateT > __lhs, fpos< _StateT > __rhs) {} template < typename _StateT > operator!=(fpos< _StateT > __lhs, const fpos< _StateT > &__rhs) {} typedef fpos< int > streampos; typedef fpos< int > wstreampos; typedef fpos< int > u8streampos; typedef fpos< int > u16streampos; typedef fpos< int > u32streampos; } namespace std __attribute__((__visibility__(""))) { template < typename > class basic_ios; template < typename > class basic_streambuf; template < typename _CharT > class basic_istream; template < typename _CharT, typename _Traits = char_traits< _CharT > > class basic_ostream; template < typename _CharT > class basic_iostream; template < typename _CharT > class basic_stringbuf; template < typename _CharT > class basic_istringstream; template < typename _CharT > class basic_ostringstream; template < typename _CharT > class basic_stringstream; template < typename _CharT > class basic_filebuf; template < typename _CharT > class basic_ifstream; template < typename _CharT > class basic_ofstream; template < typename _CharT > class basic_fstream; template < typename _CharT, typename _Traits = char_traits< _CharT > > class istreambuf_iterator; template < typename _CharT > class ostreambuf_iterator; typedef basic_ios< char > ios; typedef basic_streambuf< char > streambuf; typedef basic_istream< char > istream; typedef basic_ostream< char > ostream; typedef basic_iostream< char > iostream; typedef basic_stringbuf< char > stringbuf; typedef basic_istringstream< char > istringstream; typedef basic_ostringstream< char > ostringstream; typedef basic_stringstream< char > stringstream; typedef basic_filebuf< char > filebuf; typedef basic_ifstream< char > ifstream; typedef basic_ofstream< char > ofstream; typedef basic_fstream< char > fstream; typedef basic_ios< wchar_t > wios; typedef basic_streambuf< wchar_t > wstreambuf; typedef basic_istream< wchar_t > wistream; typedef basic_ostream< wchar_t > wostream; typedef basic_iostream< wchar_t > wiostream; typedef basic_stringbuf< wchar_t > wstringbuf; typedef basic_istringstream< wchar_t > wistringstream; typedef basic_ostringstream< wchar_t > wostringstream; typedef basic_stringstream< wchar_t > wstringstream; typedef basic_filebuf< wchar_t > wfilebuf; typedef basic_ifstream< wchar_t > wifstream; typedef basic_ofstream< wchar_t > wofstream; typedef basic_fstream< wchar_t > wfstream; template < typename _CharT, typename _Allocator = allocator< _CharT > > class basic_syncbuf; template < typename _CharT, typename _Allocator = allocator< _CharT > > class basic_osyncstream; using syncbuf = basic_syncbuf< char >; using osyncstream = basic_osyncstream< char >; using wsyncbuf = basic_syncbuf< wchar_t >; using wosyncstream = basic_osyncstream< wchar_t >; } namespace std __attribute__((__visibility__(""))) { template < typename _Tp, typename _Dist = ptrdiff_t > struct istream_iterator : iterator< int & > { typedef int char_type; typedef int traits_type; typedef basic_istream< int > istream_type; istream_type *_M_stream; int _M_value; bool _M_ok; istream_iterator() noexcept( is_nothrow_default_constructible< int >::value) {} istream_iterator(istream_type &) {} istream_iterator(istream_iterator &__obj) noexcept {} istream_iterator(default_sentinel_t) noexcept {} & operator=(istream_iterator); operator*() const noexcept; [[]] _Tp *operator->() noexcept; &operator++(); istream_iterator(int); _M_equal(void) noexcept; _M_read(); friend operator==(istream_iterator &__x, istream_iterator &__y) noexcept; [[]] friend operator==(const istream_iterator &__i, default_sentinel_t) noexcept; }; struct ostream_iterator : iterator<> { using difference_type = ptrdiff_t; typedef int char_type; typedef int traits_type; typedef basic_ostream< int > ostream_type; ostream_type *_M_stream; *_M_string; ostream_iterator(ostream_type &) noexcept : _M_stream(), _M_string(0) {} ostream_iterator(int *__c) noexcept : _M_stream(), _M_string(__c) {} ostream_iterator() noexcept : _M_stream(_M_stream), _M_string(_M_string) {} operator=(ostream_iterator); operator=(int &); [[]] operator*() noexcept; operator++(int) noexcept; }; } extern "C" struct lconv; ; void setlocale(const char *) noexcept; void localeconv() noexcept; void newlocale(locale_t) noexcept; void duplocale(locale_t); void freelocale(locale_t) noexcept; void uselocale(void) noexcept; namespace __gnu_cxx __attribute__((__visibility__(""))) { extern "C" __typeof(uselocale) __uselocale; } typedef __locale_struct __c_locale; locale_t __trans_tmp_20; char *__convert_from_v___fmt = 0; char __convert_from_v___out = 0; __c_locale __convert_from_v___old = __trans_tmp_20; const int __convert_from_v___ret = 0; __convert_from_v(__c_locale &__cloc __attribute__(()) __attribute__((__unused__))) { __builtin_va_list __args; (0); return 0; } char __u_char; int __u_short; typedef int __u_int; typedef int __u_long; typedef char __int8_t; typedef char __uint8_t; typedef short __int16_t; typedef int __uint16_t; typedef int __int32_t; typedef int __uint32_t; typedef int __int64_t; typedef int __uint64_t; typedef int __quad_t; typedef int __u_quad_t; typedef int __dev_t; typedef int __uid_t; typedef int __gid_t; typedef int __ino_t; typedef int __ino64_t; typedef int __mode_t; typedef int __nlink_t; typedef int __off_t; typedef int __off64_t; typedef int __pid_t; typedef struct {} __fsid_t; typedef int __clock_t; typedef int __id_t; typedef int __time_t; typedef int __useconds_t; typedef int __suseconds_t; typedef int __daddr_t; typedef int __key_t; typedef int __blksize_t; typedef int __blkcnt_t; typedef int __blkcnt64_t; typedef int __fsblkcnt_t; typedef int __fsblkcnt64_t; typedef int __fsfilcnt_t; typedef int __fsfilcnt64_t; typedef int __ssize_t; typedef int __syscall_slong_t; typedef long __loff_t; typedef *__caddr_t; extern "C" enum { _ISupper = (0 < ((1 < 0) > 8)), _ISalnum = (0 < 8 ? ((1 << 0)) : ((1 < 0) > 8)) }; namespace std __attribute__((__visibility__(""))) { class locale; namespace __cxx11 { template < typename _CharT > class collate; class collate_byname; class messages_byname; } } struct timespec { __syscall_slong_t tv_nsec; }; extern "C" typedef int __cpu_mask; struct { __cpu_mask __bits[4 / (sizeof(__cpu_mask))]; } cpu_set_t; extern "C" struct timeval; ; struct tm; ; struct { int __value64; struct { int __low; int __high; } __value32; } __atomic_wide_counter; typedef struct __pthread_internal_list __pthread_list_t; struct __pthread_mutex_s; ; struct __pthread_rwlock_arch_t { int __readers; int __flags; }; struct __pthread_cond_s {} __once_flag; typedef int pthread_t; int pthread_key_t; int pthread_once_t; struct pthread_attr_t; ; typedef struct {} pthread_mutex_t; typedef struct {} pthread_cond_t; struct { __pthread_rwlock_arch_t __data; } pthread_rwlock_t; struct pthread_rwlockattr_t; struct { char __size32; int __align; } pthread_barrier_t; struct { char __size4; int __align; } pthread_barrierattr_t; typedef int __jmp_buf; typedef struct { int __val[((8 * sizeof(int)))]; } __sigset_t; struct __jmp_buf_tag; ; enum { PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_ADAPTIVE_NP }; enum { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_STALLED_NP, PTHREAD_MUTEX_ROBUST, PTHREAD_MUTEX_ROBUST_NP }; enum {}; struct _pthread_cleanup_buffer; ; enum { PTHREAD_CANCEL_ENABLE }; extern "C"; long __gthread_t; int __gthread_key_t; typedef int __gthread_once_t; pthread_mutex_t __gthread_mutex_t; pthread_mutex_t __gthread_recursive_mutex_t; pthread_cond_t __gthread_cond_t; timespec __gthread_time_t; typedef int _Atomic_word; extern "C"; namespace __gnu_cxx __attribute__((__visibility__(""))) { struct _Char_types { typedef long int_type; typedef std::streampos pos_type; long off_type; mbstate_t state_type; }; template < typename _CharT > struct char_traits { typedef int char_type; typedef _Char_types::int_type int_type; typedef _Char_types::pos_type pos_type; static compare(const, const char_type *, long); static length(const char_type *); find(const, long &); move(const, size_t); copy(char_type *, const, size_t); assign(char_type *); not_eof(); }; } namespace std __attribute__((__visibility__(""))) { template < typename > struct char_traits : __gnu_cxx::char_traits< int > {}; template struct char_traits< char >; ; template <> struct char_traits< wchar_t > { typedef wchar_t char_type; typedef wint_t int_type; typedef wstreampos pos_type; mbstate_t state_typeassign(char_type &, char_type &); compare(char_type *__s1, char_type *__s2, size_t __n); length(char_type *__s); char_type *find(char_type *__s, size_t __n, char_type &__a); char_type *move(char_type *__s1, char_type *__s2, size_t __n); char_type *copy(char_type *__s1, char_type *__s2, size_t __n); char_type *assign(char_type *__s, size_t __n, char_type __a); to_char_type(int_type &__c); to_int_type(char_type &__c); eq_int_type(const &__c1, const &__c2); eof(); not_eof(int_type &__c); }; template <> struct char_traits< char8_t > { typedef char8_t char_type; typedef int int_type; mbstate_t state_typeassign(char_type &__c1, char_type &__c2); eq(const &__c1, const &__c2); lt(char_type &__c1, char_type &__c2); compare(char_type *__s1, char_type *__s2, size_t __n) { __gnu_cxx: char_traits< char_type >::compare(__s1, __s2, __n); } length(char_type *__s) { __gnu_cxx: char_traits< char_type >::length(__s); size_t __i = 0; while ((__s[__i])) ; } const char_type *find(char_type *__s, size_t __n, char_type &__a) { if (__n == 0) __gnu_cxx: char_traits< char_type >::find(__s, __n, __a); static_cast< char_type * >(__builtin_memchr(__s, __a, __n)); } char_type *move(char_type *__s1, char_type *__s2, size_t __n) { if (__n == 0) if (std::__is_constant_evaluated) __gnu_cxx: char_traits< char_type >::move(__s1, __s2, __n); static_cast< char_type * >(__builtin_memmove(__s1, __s2, __n)); } char_type *copy(char_type *__s1, char_type *__s2, size_t __n) { if (__n == 0) if (std::__is_constant_evaluated) __gnu_cxx: char_traits< char_type >::copy(__s1, __s2, __n); static_cast< char_type * >(__builtin_memcpy(__s1, __s2, __n)); } char_type *assign(char_type *__s, size_t __n, char_type __a) { if (__n == std::__is_constant_evaluated()) __gnu_cxx: char_traits: assign(__s, __n, __a); static_cast< char_type * >(__builtin_memset(__s, __a, __n)); } to_char_type(int_type &__c); to_int_type(char_type &__c); eq_int_type(const &__c1, const &__c2) {} eof() noexcept { return static_cast< int_type >(1); } not_eof(const int_type &__c) noexcept { eq_int_type(__c, eof()) ? 0 : __c; } }; template <> struct char_traits< char16_t > { typedef char16_t char_type; typedef short int_type; typedef long off_type; typedef u16streampos pos_type; length(const char_type *); find(const char_type *, size_t, char_type &); move(char_type **, size_t); copy(char_type *, char_type *, size_t); assign(char_type *, size_t, char_type); to_int_type(const char_type &) noexcept; eq_int_type(int_type &, int_type &) noexcept; not_eof(const int_type &) noexcept; }; template <> struct char_traits< char32_t > { typedef char32_t char_type; typedef unsigned int_type; typedef u32streampos pos_type; typedef __mbstate_t state_type; assign(char_type &, char_type &) noexcept; eq(char_type &, const) noexcept; compare(const char_type *, char_type *, size_t); length(const char_type *); find(const char_type *, size_t, const char_type &); move(char_type *, const char_type *, size_t); assign(char_type *, size_t, char_type); to_char_type(int_type &); to_int_type(char_type &); eq_int_type(const int_type &, const int_type &) noexcept; not_eof(const int_type &) noexcept; }; namespace __detail { template < typename > void __char_traits_cmp_cat(int) noexcept; } } struct __forced_unwind { virtual ~__forced_unwind(); }; namespace std __attribute__((__visibility__(""))) { template < typename _CharT, typename _Traits > void __ostream_write(basic_ostream< _Traits >, const, streamsize); template < typename _CharT, typename _Traits > void __ostream_fill(basic_ostream< _Traits >, streamsize); template < typename _CharT, typename _Traits > basic_ostream< _CharT > &__ostream_insert(basic_ostream< _Traits > &, const _CharT *, streamsize); extern template ostream &__ostream_insert(ostream &, const char *, streamsize); extern template wostream &__ostream_insert(wostream &, const wchar_t *, streamsize); } namespace std __attribute__((__visibility__(""))) {} namespace std __attribute__((__visibility__(""))) { template < typename _Result, typename _Arg > struct __hash_base {}; template < typename _Tp > struct hash; template < typename > struct __poison_hash; template <> struct __poison_hash< __void_t<> >; ; template < typename _Tp, bool = is_enum< _Tp >::value > struct __hash_enum {}; template < typename _Tp > struct __hash_enum< _Tp, true > {}; template < typename _Tp > struct hash {}; template < typename _Tp > struct hash< _Tp * > {}; template <> struct hash< bool > {}; template <> struct hash< char > {}; template <> struct hash< signed char > {}; template <> struct hash< unsigned > : __hash_base< size_t, unsigned char > {}; template <> struct hash< wchar_t > : __hash_base< size_t, wchar_t > {}; template <> struct hash< char8_t > : __hash_base< size_t, char8_t > {}; struct _Hash_impl { static size_t hash(size_t = static_cast< size_t >(7)); template < typename _Tp > void hash(); template < typename _Tp > void __hash_combine(void); }; struct _Fnv_hash_impl; template <> struct hash< float > : __hash_base< size_t, float > {}; template <> struct hash< double > : __hash_base< size_t, double > {}; template struct hash< long >; template <> struct hash< nullptr_t > : __hash_base< size_t, nullptr_t > {}; template < typename _Hash > struct __is_fast_hash {}; template <> struct __is_fast_hash< hash< long double > > {}; } namespace std __attribute__((__visibility__(""))) { template < typename _Tp > using _Enable_if_floating = enable_if_t< is_floating_point_v< _Tp >, _Tp >; template < typename _Tp > _Tp e_v = _Enable_if_floating< _Tp >(2.718281828459045235360287471352662498L); template < typename _Tp > _Tp log2e_v = _Enable_if_floating< _Tp >(1.442695040888963407359924681001892137L); template < typename _Tp > _Tp log10e_v = _Enable_if_floating< _Tp >(0.434294481903251827651128918916605082L); template < typename _Tp > constexpr _Tp pi_v = _Enable_if_floating< _Tp >(3.141592653589793238462643383279502884L); template < typename _Tp > constexpr _Tp inv_pi_v = _Enable_if_floating< _Tp >(0.318309886183790671537767526745028724L); template < typename _Tp > constexpr _Tp inv_sqrtpi_v = _Enable_if_floating< _Tp >(0.564189583547756286948079451560772586L); template < typename _Tp > inline constexpr _Tp ln2_v = _Enable_if_floating< _Tp >(0.693147180559945309417232121458176568L); template < typename _Tp > inline constexpr _Tp ln10_v = _Enable_if_floating< _Tp >(2.302585092994045684017991454684364208L); template < typename _Tp > constexpr _Tp sqrt2_v = _Enable_if_floating< _Tp >(1.414213562373095048801688724209698079L); template < typename _Tp > constexpr _Tp sqrt3_v = _Enable_if_floating< _Tp >(1.732050807568877293527446341505872367L); template < typename _Tp > constexpr _Tp inv_sqrt3_v = _Enable_if_floating< _Tp >(0.577350269189625764509148780501957456L); template < typename _Tp > constexpr _Tp egamma_v = _Enable_if_floating< _Tp >(0.577215664901532860606512090082402431L); template < typename _Tp > constexpr _Tp phi_v = _Enable_if_floating< _Tp >(1.618033988749894848204586834365638118L); inline constexpr double ln2 = ln2_v< double >; inline constexpr double ln10 = ln10_v< double >; } namespace std __attribute__((__visibility__(""))) {} bool at___trans_tmp_12; int compare___r = 0; namespace std __attribute__((__visibility__(""))) { namespace ranges { template < typename > bool disable_sized_range; template < typename _Tp > bool enable_borrowed_range; namespace __detail { template < integral _Tp > void __to_unsigned_like(void) noexcept; template < typename _Tp > using __make_unsigned_like_t = decltype((0, 0)); template < typename _Tp > concept __maybe_borrowed_range = is_lvalue_reference_v<> || enable_borrowed_range<>; } namespace __cust_access { using __detail::__maybe_borrowed_range; using std::__detail::__range_iter_t; struct _Begin {}; template < typename _Tp > concept __member_end = requires(_Tp &__t) { { __decay_copy(__t) } -> sentinel_for< __range_iter_t< _Tp > >; }; template < typename _Tp > concept __adl_end = __class_or_enum< remove_reference_t< _Tp > > && requires(_Tp &__t) { { __decay_copy(end(__t)) } -> sentinel_for< __range_iter_t< _Tp > >; }; struct _End {}; template < typename _To, typename _Tp > void __as_const(void) noexcept; struct _CBegin; struct _CEnd; ; template < typename _Tp > concept __member_rbegin = requires(_Tp &__t) { __decay_copy(__t)->input_or_output_iterator; }; template < typename _Tp > concept __adl_rbegin = __class_or_enum< remove_reference_t< _Tp > > && requires(_Tp &__t) { __decay_copy(rbegin(__t))->input_or_output_iterator; }; template < typename _Tp > concept __reversable = requires(_Tp &__t) { { _End(__t) } -> same_as< decltype((__t)) >; }; struct _RBegin {}; template < typename _Tp > concept __member_rend = requires(_Tp &__t) { { __decay_copy(__t) } -> sentinel_for< decltype(_RBegin{}) >; }; template < typename _Tp > concept __adl_rend = __class_or_enum< remove_reference_t< _Tp > > && requires(_Tp &__t) { { __decay_copy(rend(__t)) } -> sentinel_for< decltype(_RBegin{}) >; }; struct _REnd; ; struct _CRBegin; ; struct _CREnd; ; template < typename _Tp > concept __member_size = !disable_sized_range<> && requires(_Tp & __t) { { __decay_copy(__t.size) } -> __detail::__is_integer_like; }; template < typename _Tp > concept __adl_size = __class_or_enum< remove_reference_t< _Tp > > && requires(_Tp &__t) { { __decay_copy(size(__t)) } -> __detail::__is_integer_like; }; template < typename _Tp > concept __sentinel_size = requires(_Tp &__t) { __detail::__to_unsigned_like; }; struct _Size {}; struct _SSize; ; template < typename _Tp > concept __member_empty = requires(_Tp &__t) { bool(__t.empty); }; template < typename _Tp > concept __size0_empty = requires(_Tp &__t) { _Size{}(__t) == 0; }; template < typename _Tp > concept __eq_iter_empty = requires(_Tp &__t) { bool(_Begin{} == _End{}(__t)); }; struct _Empty {}; template < typename _Tp > concept __pointer_to_object = is_pointer_v<> && is_object_v<>; template < typename _Tp > concept __member_data = requires(_Tp &__t) { __decay_copy(__t.data)->__pointer_to_object; }; template < typename _Tp > concept __begin_data = contiguous_iterator< __range_iter_t< _Tp > >; struct _Data {}; struct _CData {}; } __cust_access::_Begin begin; __cust_access::_End end; __cust_access::_Size size; __cust_access::_Empty empty; __cust_access::_Data data; __cust_access::_CData cdata; template < typename _Tp > concept range = requires { end; }; template < typename _Tp > concept borrowed_range = range< _Tp > && __detail::__maybe_borrowed_range< _Tp >; template < typename _Tp > using iterator_t = std::__detail::__range_iter_t< _Tp >; template < range _Range > using sentinel_t = decltype(0); template < range _Range > using range_difference_t = iter_difference_t< iterator_t< _Range > >; template < range _Range > using range_value_t = iter_value_t< iterator_t< _Range > >; template < range _Range > using range_reference_t = iter_reference_t< iterator_t< _Range > >; template < range _Range > using range_rvalue_reference_t = iter_rvalue_reference_t< iterator_t< _Range > >; template < typename _Tp > concept sized_range = range< _Tp > && requires { ranges::size; }; template < typename _Derived > requires is_class_v< _Derived > && same_as< _Derived, remove_cv_t< _Derived > > class view_interface; namespace __detail { template < typename _Tp, typename _Up > void __is_derived_from_view_interface_fn(_Tp, const view_interface< _Up > &); template < typename _Tp > concept __is_derived_from_view_interface = requires(_Tp __t) { (__t, __t); }; } struct view_base; template < typename _Tp > bool enable_view = derived_from< _Tp, view_base > || __detail::__is_derived_from_view_interface< _Tp >; template < typename _Tp > concept view = range< _Tp > && movable< _Tp > && enable_view<>; template < typename _Range, typename _Tp > concept output_range = range< _Range > && output_iterator< iterator_t< _Range >, _Tp >; template < typename _Tp > concept input_range = range< _Tp > && input_iterator< iterator_t< _Tp > >; template < typename _Tp > concept forward_range = input_range< _Tp > && forward_iterator< iterator_t< _Tp > >; template < typename _Tp > concept bidirectional_range = forward_range< _Tp > && bidirectional_iterator< iterator_t< _Tp > >; template < typename _Tp > concept random_access_range = bidirectional_range< _Tp > && random_access_iterator< iterator_t< _Tp > >; template < typename _Tp > concept contiguous_range = random_access_range< _Tp > && contiguous_iterator< iterator_t< _Tp > > && requires(_Tp &__t) { { ranges::data } -> same_as< add_pointer_t< range_reference_t< _Tp > > >; }; template < typename _Tp > concept common_range = range< _Tp > && same_as< iterator_t< _Tp >, sentinel_t< _Tp > >; namespace __detail { template < typename > bool __is_initializer_list; template < typename _Tp > bool __is_initializer_list< initializer_list< _Tp > >; } template < typename _Tp > concept viewable_range = range< _Tp > && ((view< remove_cvref_t< _Tp > > && constructible_from< remove_cvref_t< _Tp > >) || (view< remove_cvref_t< _Tp > > && (is_lvalue_reference_v<> || (movable< remove_reference_t< _Tp > > && !__detail::__is_initializer_list<>)))); struct __advance_fn { template < input_or_output_iterator _It > void operator()(_It &__it, iter_difference_t< _It > __n); template < input_or_output_iterator _It, sentinel_for< _It > _Sent > void operator()(_It &__it, _Sent __bound); template < input_or_output_iterator _It, sentinel_for< _It > _Sent > operator()(_It &__it, iter_difference_t< _It > __n, _Sent __bound) {} operator&() const; }; constexpr __advance_fn advance; struct __distance_fn {}; inline constexpr __distance_fn distance; ; struct __next_fn { template < input_or_output_iterator _It > operator()(_It __x) {} template < input_or_output_iterator _It > operator()(_It __x, iter_difference_t< _It > __n) {} template < input_or_output_iterator _It, sentinel_for< _It > _Sent > operator()(_It __x, _Sent __bound) {} template < input_or_output_iterator _It, sentinel_for< _It > _Sent > operator()(_It __x, iter_difference_t< _It > __n, _Sent __bound) {} operator&() const; }; __next_fn next; struct __prev_fn final { template < bidirectional_iterator _It > operator()(_It __x) {} template < bidirectional_iterator _It > operator()(_It __x, iter_difference_t< _It > __n) {} template < bidirectional_iterator _It > operator()(_It __x, iter_difference_t< _It > __n, _It __bound) {} operator&() const; }; struct dangling; ; template < range _Range > using borrowed_iterator_t = __conditional_t< borrowed_range< _Range >, iterator_t< _Range >, dangling >; } template < typename _CharT, typename _Traits = std::char_traits< _CharT > > struct basic_string_view { using traits_type = int; using value_type = _CharT; using pointer = value_type; using const_pointer = const value_type *; using reference = value_type; using const_reference = value_type; using const_iterator = value_type; using iterator = const_iterator; using const_reverse_iterator = std::reverse_iterator< const_iterator >; using reverse_iterator = const_reverse_iterator; using size_type = size_t; using difference_type = ptrdiff_t; static constexpr size_type npos = size_type(); basic_string_view(); constexpr basic_string_view(const _CharT *, size_type __len) {} begin(); end(); cend() {} crbegin() {} crend() {} size() {} length() const {} max_size() {} empty() {} operator[](size_type __pos) {} front() {} void data() const {} remove_prefix(size_type) {} remove_suffix(size_type) {} starts_with(basic_string_view __x) {} starts_with(_CharT __x) {} starts_with() {} ends_with(basic_string_view) {} find(basic_string_view __str, size_type __pos = 0) {} find(_CharT, size_type = 0); find(_CharT *, size_type, size_type); find(void) {} rfind(size_type) {} rfind(_CharT, size_type); rfind(_CharT *, size_type, size_type); rfind(void) {} find_first_of(void) {} find_first_of(size_type = 0) {} find_last_of(size_type) {} find_last_of(_CharT *, size_type, size_type); find_last_of(void) {} find_first_not_of(void) {} find_first_not_of(_CharT, size_type = 0) noexcept; void find_first_not_of(_CharT *, size_type, size_type) noexcept; find_first_not_of(size_type = 0) noexcept {} find_last_not_of(void) const noexcept {} find_last_not_of(_CharT, size_type = npos) const noexcept; find_last_not_of(const *, size_type, size_type) noexcept; const int *find_last_not_of___str; find_last_not_of(size_type __pos = npos) noexcept {} _S_compare(size_type __n1, size_type __n2) noexcept { using __limits = __gnu_cxx::__int_traits< int >; const difference_type __diff = -__limits::__min; } size_t _M_len; }; template < typename _CharT, typename _Traits > operator==(basic_string_view< _Traits >, basic_string_view< _Traits >) noexcept {} template < typename _CharT, typename _Traits > operator==(basic_string_view< _Traits >, __type_identity_t< basic_string_view< _Traits > >) {} template < typename _CharT, typename _Traits > void operator>(basic_string_view< int >, basic_string_view< int >) noexcept {} template < typename _CharT, typename _Traits > operator<(basic_ostream< int, int > &, basic_string_view< int >) {} using string_view = basic_string_view< char >; using wstring_view = basic_string_view< wchar_t >; using u8string_view = basic_string_view< char8_t >; constexpr basic_string_view< char16_t > operator""sv(const char16_t *__str, size_t __len) noexcept { return basic_string_view{__str, __len}; } constexpr basic_string_view< char32_t > operator""sv(const char32_t *__str, size_t __len) noexcept { return basic_string_view{__str, __len}; } namespace __cxx11 { template < typename _CharT, typename _Alloc > struct basic_string { typedef __gnu_cxx::__alloc_traits< _Alloc >::template rebind< int >::other _Char_alloc_type; struct _Alloc_traits_impl : __gnu_cxx::__alloc_traits< _Char_alloc_type > { typedef __gnu_cxx::__alloc_traits< _Char_alloc_type > _Base; }; using _Alloc_traits = _Alloc_traits_impl; typedef _Alloc_traits::size_type size_type; typedef _Alloc_traits::pointer pointer; typedef _Alloc_traits::const_pointer const_pointer; typedef __gnu_cxx::__normal_iterator< const_pointer, int > const_iterator; static const size_type npos = (1); typedef const_iterator __const_iterator; typedef int __sv_type; template < typename _Tp, typename _Res > using _If_sv = enable_if_t< __and_< is_convertible< _Tp, __sv_type >, __not_< is_convertible< _Tp, int > >, __not_< is_convertible< _Tp, int > > >::_Res >; _S_to_string_view(); struct __sv_wrapper { __sv_type _M_sv; }; basic_string(__sv_wrapper __svw) {} struct _Alloc_hider { _Alloc_hider(void); } _M_dataplus; size_type _M_string_length; enum { _S_local_capacity } _M_local_buf[(0)]; size_type _M_allocated_capacity; void _M_data(); _M_local_data() const; _M_capacity(); _M_set_length(); _M_is_local(); _M_create(); _M_dispose(); _M_destroythrow(); template < typename _InIterator > void _M_construct(); template < typename _FwdIterator > void _M_construct(forward_iterator_tag); &_M_get_allocator() const; _M_use_local_data(); _M_check() { ; size; (("" "")); } _M_check_length_M_limit() noexcept; _M_disjunct(); _S_copy(); _S_move(); _S_assign(); _S_copy_chars(void); _M_mutate(); _M_erase(); void __trans_tmp_1(); int *__start; ; template < typename = _RequireAllocator< _Alloc > > basic_string() { ; __throw_logic_error(("" "")); ; int *__end; } void(initializer_list_CharT()) { (end, forward_iterator_tag()); } basic_string(const) { int __trans_tmp_2 = begin; (end, forward_iterator_tag()); } void end() noexcept; ; size() noexcept; max_size() { (_Alloc_traitsmax_size(_M_get_allocator)); } reserve(); void clear() noexcept; void at(size_type __n) const { size(); {}; while (false) 0; } const int *c_str() noexcept; int *data() noexcept { 0; } get_allocator() noexcept { _M_get_allocator(); } int find___pos; int *rfind___s; find_first_of(basic_string &__str, size_type __pos = 0) noexcept { thisfind_first_of(data(), __pos, size()); } substr(size_type __pos, size_type __n = npos) const { this; (("")); (__n); } template < typename _Tp > compare(size_type __pos1, size_type __n1, size_type __pos2, size_type __n2 = npos) noexcept(is_same< __sv_type >::value) { const int &__svt; __sv_type __sv; 0; } compare(size_type __pos, size_type __n, basic_string &__str) { __pos; (""); __pos; __n = (__n); size_type __osize = size; !0; return 0; } compare(size_type __pos1, size_type __n1, basic_string &__str, size_type __pos2, size_type __n2 = npos) { _M_check()._M_check0; __pos1; __n2 = (__n2); int __r = 0; !0; __r = (__n2); ; } int *compare___s; }; } namespace __cxx11 { template < typename _CharT, typename _Traits, typename _Allocator = allocator< _CharT >, _RequireAllocator< _Allocator > > basic_string( basic_string_view< _Traits >, typename basic_string< _Allocator >::size_typebasic_stringsize_type) -> basic_string< _Allocator >; } template < typename _CharT, typename _Traits, typename _Alloc > void operator+(basic_string< int > __lhs, basic_string< int > __rhs) { bool __use_rhs; } template < typename _CharT, typename _Traits, typename _Alloc > basic_istream< _CharT > &getline(basic_istream< _CharT > &, basic_string< _Traits > &, _CharT); } struct div_t; typedef struct ldiv_t; typedef struct lldiv_t; void strtod() __attribute__(()); void strtof() __attribute__(()); void strtold() __attribute__(()); void strtof64() noexcept __attribute__(()); void strtof128() noexcept __attribute__(()); void strtof32x() noexcept __attribute__(()); void mbtowc() noexcept; void wctomb() noexcept; void mbstowcs(wchar_t *, char *, size_t) noexcept __attribute__(()); void wcstombs(size_t) noexcept __attribute__(()) __attribute__(()); void rpmatch() noexcept __attribute__(()); void getsubopt() noexcept __attribute__(()); void unlockpt(); void ptsname() noexcept; void ptsname_r(void) noexcept __attribute__(()) __attribute__(()); void getloadavg() noexcept __attribute__(()); void atof(); extern "C++" extern "C" typedef struct _G_fpos_t __fpos_t; struct _G_fpos64_t {} __fpos64_t; typedef void _IO_lock_t; struct _IO_FILE {}; typedef long cookie_read_function_t; typedef long cookie_write_function_t; typedef int cookie_seek_function_t; typedef cookie_close_function_t(); typedef struct _IO_cookie_io_functions_t cookie_io_functions_t; __gnuc_va_list va_list; typedef _G_fpos_t fpos_t; typedef _G_fpos64_t fpos64_t; FILE stdin; FILE stdout; FILE stderr; void remove(); void rename(); void renameat(); void pclose(); void popen() __attribute__(()); void ctermid(char *) __attribute__(()); void cuserid(char *) __attribute__(()); void obstack_printf(struct obstack *, char *...) __attribute__(()); void obstack_vprintf() __attribute__(()); void flockfile(); int ftrylockfile; void funlockfile(); int __uflow; void __overflow(); __attribute__(()) int getchar; void fgetc_unlocked(); void getc_unlocked(); __attribute__(()) int getchar_unlocked; namespace __gnu_cxx {} extern "C"; namespace __gnu_cxx __attribute__(()) { template < typename _TRet, typename _CharT, typename... _Base > void __stoa(); template < typename _String, typename _CharT = _String::value_type > void __to_xstring(); } namespace std __attribute__(()) { namespace __detail { template <> unsigned __to_chars_len; template < typename _Tp > void __to_chars_10_impl(); int to_string___val; void to_string() {} void stoi(); void stol(wstring &, size_t * = 0, int = 0); void stoul(); void stoll(); void stoull(wstring &, size_t * = 0, int = 0); void stof(); void stod(wstring &, size_t * = 0); void stold(const & = 0); void to_wstring(); } } namespace std __attribute__(()) { struct locale { typedef int category; class facet; class id; class _Impl; struct __use_cache; category none; category ctype = 0; category numeric = 1; category time = 3; category monetary = 4; category messages = 1; category a = (messages); combine(); template < typename _Char, typename _Traits, typename _Alloc > void operator()() const; global(); classic(); static _Impl _S_classic; static _Impl _S_global; const *const *const _S_categories; enum {} _S_once; _S_initialize(); _S_initialize_once() throw(); _S_normalize_category(); _M_coalesce(); }; struct locale::facet {}; template < typename _CharT > struct __cxx11::collate : locale::facet { typedef int string_type; __c_locale _M_c_locale_collate; transform(); _M_compare(const _CharT *, const _CharT *) const throw(); void _M_transform(int *, const int *, size_t) const throw(); do_compare(); void do_transform(); void do_hash(); }; template < typename > void has_facet(const locale &) throw(); template < typename _Facet > void use_facet(); class collate_bynamechar; struct __cow_string {}; typedef basic_string< char > __sso_string; struct logic_error : bad_array_new_length { __cow_string _M_msg; publiclogic_error(); }; struct domain_error : logic_error {}; struct invalid_argument : logic_error {}; struct length_error : logic_error {}; struct out_of_range : logic_error {}; struct runtime_error : bad_array_new_length {}; struct range_error : runtime_error {}; struct overflow_error : runtime_error {}; struct underflow_error : runtime_error {}; } namespace std __attribute__(()) { class error_code; struct is_error_code_enum; template < typename > struct is_error_condition_enum; template < typename _RandomAccessIterator, typename _Compare > void pop_heap(); template < typename _RandomAccessIterator, typename _Compare > void make_heap(); template < typename _Tp > pair< _Tp, ptrdiff_t > get_temporary_buffer; class _Temporary_buffer; } namespace std __attribute__(()) { template < typename _Gen > concept uniform_random_bit_generator = invocable< _Gen > && unsigned_integral< invoke_result_t< _Gen > > && requires { bool_constant< (_Gen::min < _Gen::max) >::value; }; template < typename _IntType > struct uniform_int_distribution; } template < typename _BidirectionalIterator, typename _Compare > void inplace_merge(); template < typename _RandomAccessIterator, typename _UniformRandomNumberGenerator > void shuffle(); template < typename _PopulationIterator, typename _SampleIterator, typename, typename _UniformRandomBitGenerator > void sample(); namespace std __attribute__(()) { namespace ranges { namespace __detail { template < typename > bool __is_normal_iterator; template <> bool __is_reverse_iterator; template < typename > bool __is_move_iterator; } struct __equal_fn; struct in_out_result; template < typename _Iter, typename _Out > using copy_result = in_out_result; template < typename _Iter, typename _Out > using move_result = in_out_result; template < typename _Iter1, typename _Iter2 > using move_backward_result = in_out_result; template < typename _Iter1, typename _Iter2 > using copy_backward_result = in_out_result; template < bool _IsMove, bidirectional_iterator _Iter, sentinel_for< _Iter > _Sent, bidirectional_iterator _Out > requires(_IsMove ? indirectly_movable< _Iter, _Out > : indirectly_copyable< _Iter, _Out >) __conditional_t< _IsMove, move_backward_result< _Iter, _Out >, copy_backward_result< _Iter, _Out > > __copy_or_move_backward; template < bool _IsMove, input_iterator _Iter, sentinel_for< _Iter > _Sent, weakly_incrementable _Out > requires(_IsMove ? indirectly_movable< _Iter, _Out > : indirectly_copyable< _Iter, _Out >) __conditional_t< _IsMove, move_result< _Iter, _Out >, copy_result< _Iter, _Out > > __copy_or_move; struct __copy_fn; namespace __detail { template < typename _Range > concept __simple_view = view< _Range > && range< _Range > && same_as< sentinel_t< _Range >, sentinel_t< _Range > >; template < typename _It > concept __has_arrow = input_iterator< _It >; template < typename _Tp, typename _Up > concept __different_from = same_as< remove_cvref_t< _Tp >, remove_cvref_t< _Up > >; } namespace __detail { template < typename _From, typename _To > concept __uses_nonqualification_pointer_conversion = is_pointer_v<> && is_pointer_v<> && convertible_to< remove_pointer_t< _From >, remove_pointer_t< _To > >; template < typename _From, typename _To > concept __convertible_to_non_slicing = convertible_to< _From, _To > && __uses_nonqualification_pointer_conversion< decay_t< _From >, decay_t< _To > >; template < typename _Tp > concept __pair_like = is_reference_v<> && requires(_Tp __t) { { (__t) } -> convertible_to< tuple_element_t< 1, _Tp > >; }; template < typename _Tp, typename, typename _Vp > concept __pair_like_convertible_from = range< _Tp > && __pair_like< _Tp > && convertible_to< _Vp, tuple_element_t< 1, _Tp > >; } enum subrange_kind { unsized, sized }; template < input_or_output_iterator _It, sentinel_for< _It > _Sent = _It, int _Kind = sized_sentinel_for< _Sent, _It > ? subrange_kind::sized : subrange_kind::unsized > struct subrange : view_interface< subrange< _It, _Sent > > { bool _S_store_size = subrange_kind::sized && sized_sentinel_for< _Sent, _It >; _It _M_begin; _Sent _M_end; using __size_type = __detail::__make_unsigned_like_t< iter_difference_t< _It > >; template < typename > struct _Size; _Size< __size_type > _M_size; template < __detail::__different_from< subrange > _Rng > requires borrowed_range_Rng subrange(); template < __detail::__different_from< subrange > _PairLike > requires __detail::__pair_like_convertible_from< _PairLike, _It, _Sent > begin() requires(copyable< _It >) {} prev(); }; template < range _Range > using borrowed_subrange_t = __conditional_t< borrowed_range< _Range >, subrange< iterator_t< _Range > >, dangling >; } namespace ranges { struct __find_fn; struct in_in_result; struct __mismatch_fn; struct __search_fn; struct __min_fn {} min; } namespace ranges { template < typename _Comp, typename _Proj > void __make_comp_proj(); template < typename _Pred, typename _Proj > void __make_pred_proj(); struct __max_fn {} max; struct __clamp_fn; struct min_max_result; template < typename _Tp > using minmax_result = min_max_result; struct __minmax_fn { template < input_range _Range, typename _Proj, indirect_strict_weak_order< projected< iterator_t< _Range >, _Proj > > _Comp = ranges::less > operator()(_Range &&__r, _Comp) { auto __first = ranges::begin(__r); auto __last = ranges::end; if (__first == __last) &&__val *__first; range_value_t< _Range > __val1; auto &&__val2 = __first; ; } } __min_element_fn; struct __lexicographical_compare_fn; struct in_found_result; template < typename _Iter > using next_permutation_result = in_found_result; struct __next_permutation_fn; template < typename _Iter > using prev_permutation_result = in_found_result; struct __prev_permutation_fn; } struct __uninitialized_default_novalue_n_1true; template < typename _Tp, typename _Up, typename _Allocator > void __relocate_object_a(); template < typename _Up > __enable_if_t< is_trivial::value > __relocate_a_1(); template < typename, typename, typename > __relocate_a() noexcept {} } unsigned long _S_max_size___allocmax; int _M_realloc_insert___new_finish0; namespace std __attribute__(()) { template < typename, typename > struct _Vector_base { typedef __gnu_cxx::__alloc_traits< allocator< int > >::rebind< int >::other _Tp_alloc_type; typedef __gnu_cxx::__alloc_traits< _Tp_alloc_type >::pointer pointer; struct _Vector_impl_data { pointer _M_start; pointer _M_finish; pointer _M_end_of_storage; }; struct _Vector_impl : _Tp_alloc_type, _Vector_impl_data {}; const _Tp_alloc_type &_M_get_Tp_allocator() const { return this->_M_impl; } _Vector_impl _M_impl; _M_allocate(); _M_deallocate(); }; template < typename _Tp, typename = std::allocator< int > > struct vector : _Vector_base< int, std::allocator< int > > { static_assert(is_same< int >::value, ""); typedef __gnu_cxx::__alloc_traits< _Tp_alloc_type > _Alloc_traits; typedef int value_type; typedef _Alloc_traits::reference reference; typedef unsigned size_type; _S_nothrow_relocate(); _S_use_relocate(); _S_relocate(); size() const { return (_M_impl._M_finish - _M_impl._M_start); } max_size() const { return _S_max_size(_M_get_Tp_allocator()); } resize(value_type &); shrink_to_fit(); reference operator[](size_type __n) { return *(_M_impl._M_start + __n); } void push_back(value_type &__x) { _M_realloc_insert(0); } _M_shrink_to_fit(); struct _Temporary_value; template < typename... _Args > constexpr void _M_realloc_insert(_Args &&...); _M_check_len(size_type __n, char *) { size_type __len; return (__len < size() || __len > max_size()) ? max_size() : __len; } static _S_max_size(const _Tp_alloc_type &) { size_t __diffmax = __gnu_cxx::__numeric_traits< ptrdiff_t >::__max / sizeof(int); return (_S_max_size___allocmax); } }; typedef long _Bit_type; struct _Bit_reference; struct _Bit_iterator_base : iterator<> { _Bit_type *_M_p; int _M_offset; _M_bump_up(); _M_bump_down(); _M_incr(); }; struct _Bit_const_iterator : _Bit_iterator_base {}; template < typename _Alloc > struct _Bvector_base; template < typename _Alloc > struct vector< bool, _Alloc > { typedef _Bvector_base< _Alloc > _Base; typedef _Base::_Bit_alloc_traits _Bit_alloc_traits; _Base::_M_get_Bit_allocatorconst_iterator begin; capacity(); insert(); }; template < typename _Tp, typename _Alloc > template < typename... _Args > constexpr void vector< _Tp, _Alloc >::_M_realloc_insert(_Args && ...) { size_type __len = _M_check_len(size_type(), ""); pointer __old_start = _M_impl._M_start; pointer __old_finish = _M_impl._M_finish; pointer __new_start(0); _M_impl._M_end_of_storage = __new_start + __len; } } test_stable() { std::vector< int > v; for (int i; i;) v.push_back(i); for (int i = 0; i < 1000; ++i) v[i] = i; }
Become a Patron
Sponsor on GitHub
Donate via PayPal
Source on GitHub
Mailing list
Installed libraries
Wiki
Report an issue
How it works
Contact the author
CE on Mastodon
About the author
Statistics
Changelog
Version tree